[
    {
        "code": "def apply_option(self, cmd, option, active=True):\n        return re.sub(r'{{{}\\:(?P<option>[^}}]*)}}'.format(option),\n                      '\\g<option>' if active else '', cmd)"
    },
    {
        "code": "def make_local_static_report_files(self):\n        for static, pkgdir in self.STATIC_FILES:\n            shutil.copyfile(\n                data_filename(static, pkgdir),\n                os.path.join(self.directory, static)\n                )\n        if self.extra_css:\n            shutil.copyfile(\n                self.config.extra_css,\n                os.path.join(self.directory, self.extra_css)\n                )"
    },
    {
        "code": "def format_filesize(size):\n    for suffix in (\"bytes\", \"KB\", \"MB\", \"GB\", \"TB\"):\n        if size < 1024.0:\n            if suffix in (\"GB\", \"TB\"):\n                return \"{0:3.2f} {1}\".format(size, suffix)\n            else:\n                return \"{0:3.1f} {1}\".format(size, suffix)\n        size /= 1024.0"
    },
    {
        "code": "def add_lexicon_ref(self, lrid, name, lrtype, url, lexicon_id,\n                        lexicon_name, datcat_id=None, datcat_name=None):\n        self.lexicon_refs[lrid] = {\n            'LEX_REF_ID': lrid,\n            'NAME': name,\n            'TYPE': lrtype,\n            'URL': url,\n            'LEXICON_ID': lexicon_id,\n            'LEXICON_NAME': lexicon_name,\n            'DATCAT_ID': datcat_id,\n            'DATCAT_NAME': datcat_name\n            }"
    },
    {
        "code": "def invert_hash(self, tok_hash):\n        return [tok_encoded.decode('utf8')\n                for (_, tok_encoded) in\n                self.client.scan_keys(HASH_KEYWORD_INDEX_TABLE,\n                                      ((tok_hash,), (tok_hash,)))]"
    },
    {
        "code": "def find_unique_points(explored_parameters):\n    ranges = [param.f_get_range(copy=False) for param in explored_parameters]\n    zipped_tuples = list(zip(*ranges))\n    try:\n        unique_elements = OrderedDict()\n        for idx, val_tuple in enumerate(zipped_tuples):\n            if val_tuple not in unique_elements:\n                unique_elements[val_tuple] = []\n            unique_elements[val_tuple].append(idx)\n        return list(unique_elements.items())\n    except TypeError:\n        logger = logging.getLogger('pypet.find_unique')\n        logger.error('Your parameter entries could not be hashed, '\n                     'now I am sorting slowly in O(N**2).')\n        unique_elements = []\n        for idx, val_tuple in enumerate(zipped_tuples):\n            matches = False\n            for added_tuple, pos_list in unique_elements:\n                matches = True\n                for idx2, val in enumerate(added_tuple):\n                    if not explored_parameters[idx2]._equal_values(val_tuple[idx2], val):\n                        matches = False\n                        break\n                if matches:\n                    pos_list.append(idx)\n                    break\n            if not matches:\n                unique_elements.append((val_tuple, [idx]))\n        return unique_elements"
    },
    {
        "code": "def unfinished(cls):\n        return [\n            cls.NONE,\n            cls.SCHEDULED,\n            cls.QUEUED,\n            cls.RUNNING,\n            cls.SHUTDOWN,\n            cls.UP_FOR_RETRY,\n            cls.UP_FOR_RESCHEDULE\n        ]"
    },
    {
        "code": "def merge_left(field, local_task, remote_issue, hamming=False):\n    local_field = local_task.get(field, [])\n    remote_field = remote_issue.get(field, [])\n    if field not in local_task:\n        local_task[field] = []\n    new_count = 0\n    for remote in remote_field:\n        for local in local_field:\n            if (\n                (\n                    hamming\n                    and get_annotation_hamming_distance(remote, local) == 0\n                )\n                or (\n                    remote == local\n                )\n            ):\n                break\n        else:\n            log.debug(\"%s not found in %r\" % (remote, local_field))\n            local_task[field].append(remote)\n            new_count += 1\n    if new_count > 0:\n        log.debug('Added %s new values to %s (total: %s)' % (\n            new_count, field, len(local_task[field]),))"
    },
    {
        "code": "def images(self, query=None):\n    from sregistry.database.models import Collection, Container\n    rows = []\n    if query is not None:   \n        like = \"%\" + query + \"%\"\n        containers = Container.query.filter(or_(Container.name == query,\n                                                Container.tag.like(like),\n                                                Container.uri.like(like),\n                                                Container.name.like(like))).all() \n    else:\n        containers = Container.query.all()\n    if len(containers) > 0:\n        message = \"  [date]   [client]\\t[uri]\"\n        bot.custom(prefix='Containers:', message=message, color=\"RED\")\n        for c in containers:\n            uri = c.get_uri()\n            created_at = c.created_at.strftime('%B %d, %Y')\n            rows.append([created_at, \"   [%s]\" %c.client, uri])\n        bot.table(rows) \n    return containers"
    },
    {
        "code": "def set_max_in_flight(self, max_in_flight):\n        assert isinstance(max_in_flight, int)\n        self.max_in_flight = max_in_flight\n        if max_in_flight == 0:\n            for conn in itervalues(self.conns):\n                if conn.rdy > 0:\n                    logger.debug('[%s:%s] rdy: %d -> 0', conn.id, self.name, conn.rdy)\n                    self._send_rdy(conn, 0)\n            self.total_rdy = 0\n        else:\n            self.need_rdy_redistributed = True\n            self._redistribute_rdy_state()"
    },
    {
        "code": "def _store(self, lines, buffer=None, store='source'):\n        if buffer is None:\n            buffer = self._buffer\n        if lines.endswith('\\n'):\n            buffer.append(lines)\n        else:\n            buffer.append(lines+'\\n')\n        setattr(self, store, self._set_source(buffer))"
    },
    {
        "code": "def _ast_option_group_to_code(self, option_group, **kwargs):\n    lines = [\"option(\"]\n    lines.extend(self._indent(self._ast_to_code(option_group.expression)))\n    lines.append(\")\")\n    return lines"
    },
    {
        "code": "def add(symbol: str, date, value, currency: str):\n    symbol = symbol.upper()\n    currency = currency.upper()\n    app = PriceDbApplication()\n    price = PriceModel()\n    price.symbol.parse(symbol)\n    price.datum.from_iso_date_string(date)\n    price.value = Decimal(value)\n    price.currency = currency\n    app.add_price(price)\n    app.save()\n    click.echo(\"Price added.\")"
    },
    {
        "code": "def _close(self):\n        if self.connection:\n            with self.wrap_database_errors:\n                self.connection.client.close()"
    },
    {
        "code": "def _get_byte_parser(self):\n        if not self._byte_parser:\n            self._byte_parser = \\\n                            ByteParser(text=self.text, filename=self.filename)\n        return self._byte_parser"
    },
    {
        "code": "def _configureShortcuts(self):\n        self._upShortcut = QtGui.QShortcut(\n            QtGui.QKeySequence('Backspace'), self\n        )\n        self._upShortcut.setAutoRepeat(False)\n        self._upShortcut.activated.connect(self._onNavigateUpButtonClicked)"
    },
    {
        "code": "def update_message_dict(message_dict,action):\n    global g_ok_java_messages\n    allKeys = g_ok_java_messages.keys()\n    for key in message_dict.keys():\n        if key in allKeys:\n            for message in message_dict[key]:\n                if action == 1:\n                    if message not in g_ok_java_messages[key]:\n                        g_ok_java_messages[key].append(message)\n                if action == 2:\n                    if message in g_ok_java_messages[key]:\n                        g_ok_java_messages[key].remove(message)\n        else:\n            if action == 1:\n                g_ok_java_messages[key] = message_dict[key]"
    },
    {
        "code": "def _addHdlProcToRun(self, trigger: SimSignal, proc) -> None:\n        if not self._applyValPlaned:\n            self._scheduleApplyValues()\n        if isEvDependentOn(trigger, proc):\n            if self.now == 0:\n                return\n            self._seqProcsToRun.append(proc)\n        else:\n            self._combProcsToRun.append(proc)"
    },
    {
        "code": "def resolve_backend_name(name, backends, deprecated, aliased):\n    available = [backend.name() for backend in backends]\n    resolved_name = deprecated.get(name, aliased.get(name, name))\n    if isinstance(resolved_name, list):\n        resolved_name = next((b for b in resolved_name if b in available), \"\")\n    if resolved_name not in available:\n        raise LookupError(\"backend '{}' not found.\".format(name))\n    if name in deprecated:\n        logger.warning(\"WARNING: '%s' is deprecated. Use '%s'.\", name, resolved_name)\n    return resolved_name"
    },
    {
        "code": "def _rewrite_insert_nothing(self, sql, params, returning):\n        conflict_target = self._build_conflict_target()\n        where_clause = ' AND '.join([\n            '{0} = %s'.format(self._format_field_name(field_name))\n            for field_name in self.query.conflict_target\n        ])\n        where_clause_params = [\n            self._format_field_value(field_name)\n            for field_name in self.query.conflict_target\n        ]\n        params = params + tuple(where_clause_params)\n        return (\n            (\n                'WITH insdata AS ('\n                '{insert} ON CONFLICT {conflict_target} DO UPDATE'\n                ' SET {pk_column} = NULL WHERE FALSE RETURNING {returning})'\n                ' SELECT * FROM insdata UNION ALL'\n                ' SELECT {returning} FROM {table} WHERE {where_clause} LIMIT 1;'\n            ).format(\n                insert=sql,\n                conflict_target=conflict_target,\n                pk_column=self.qn(self.query.model._meta.pk.column),\n                returning=returning,\n                table=self.query.objs[0]._meta.db_table,\n                where_clause=where_clause\n            ),\n            params\n        )"
    },
    {
        "code": "def get_stores(self, search_term):\n        params = {'SearchText': search_term}\n        response = self.__get('/storefindermap/storesearch', params=params)\n        return Stores(response.json())"
    },
    {
        "code": "def list_recommendations(\n            self, keywords=None, max_domain_recommendations=None, custom_headers=None, raw=False, **operation_config):\n        parameters = models.DomainRecommendationSearchParameters(keywords=keywords, max_domain_recommendations=max_domain_recommendations)\n        def internal_paging(next_link=None, raw=False):\n            if not next_link:\n                url = self.list_recommendations.metadata['url']\n                path_format_arguments = {\n                    'subscriptionId': self._serialize.url(\"self.config.subscription_id\", self.config.subscription_id, 'str')\n                }\n                url = self._client.format_url(url, **path_format_arguments)\n                query_parameters = {}\n                query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n            else:\n                url = next_link\n                query_parameters = {}\n            header_parameters = {}\n            header_parameters['Accept'] = 'application/json'\n            header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n            if self.config.generate_client_request_id:\n                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n            if custom_headers:\n                header_parameters.update(custom_headers)\n            if self.config.accept_language is not None:\n                header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n            body_content = self._serialize.body(parameters, 'DomainRecommendationSearchParameters')\n            request = self._client.post(url, query_parameters, header_parameters, body_content)\n            response = self._client.send(request, stream=False, **operation_config)\n            if response.status_code not in [200]:\n                raise models.DefaultErrorResponseException(self._deserialize, response)\n            return response\n        deserialized = models.NameIdentifierPaged(internal_paging, self._deserialize.dependencies)\n        if raw:\n            header_dict = {}\n            client_raw_response = models.NameIdentifierPaged(internal_paging, self._deserialize.dependencies, header_dict)\n            return client_raw_response\n        return deserialized"
    },
    {
        "code": "def query_string(self, **params):\n        return SearchResult(self, self._api.get(self._href, **params))"
    },
    {
        "code": "def add_bias(self, name, size, mean=0, std=1):\n        mean = self.kwargs.get('mean_{}'.format(name), mean)\n        std = self.kwargs.get('std_{}'.format(name), std)\n        self._params.append(theano.shared(\n            util.random_vector(size, mean, std, rng=self.rng),\n            name=self._fmt(name)))"
    },
    {
        "code": "def ancestors(self, lhs, rhs):\n        def _search(node):\n            if node in lhs:\n                return True\n            if not node.parent:\n                return False\n            return _search(node.parent)\n        return [node for node in rhs if _search(node)]"
    },
    {
        "code": "def get_prices_on(self, on_date: str, namespace: str, symbol: str):\n        repo = self.get_price_repository()\n        query = (\n            repo.query.filter(dal.Price.namespace == namespace)\n            .filter(dal.Price.symbol == symbol)\n            .filter(dal.Price.date == on_date)\n            .order_by(dal.Price.time.desc())\n        )\n        result = query.first()\n        return result"
    },
    {
        "code": "def getEvents(self):\n        events = []\n        for json in self.conn.endpoints[\"self\"].getEvents():\n            events.append(SkypeEvent.fromRaw(self, json))\n        return events"
    },
    {
        "code": "def prepare(self):\n        self.output_dim = 10\n        self.encoder = Chain(self.input_dim).stack(Dense(self.internal_layer_size, 'tanh'))\n        self.decoder = Chain(self.internal_layer_size).stack(Dense(self.input_dim))\n        self.classifier = Chain(self.internal_layer_size).stack(Dense(50, 'tanh'),\n                                                      Dense(self.output_dim),\n                                                      Softmax())\n        self.register_inner_layers(self.encoder, self.decoder, self.classifier)\n        self.target_input = T.ivector('target')\n        self.register_external_inputs(self.target_input)"
    },
    {
        "code": "def _set_configurations(self):\n        logger.debug(\"======================\")\n        logger.debug(\"Setting configurations\")\n        logger.debug(\"======================\")\n        resources = \"\"\n        containers = \"\"\n        params = \"\"\n        manifest = \"\"\n        if self.merge_params:\n            params += self._get_merged_params_string()\n            help_list = self._get_merged_params_help()\n        else:\n            params += self._get_params_string()\n            help_list = self._get_params_help()\n        for p in self.processes:\n            if not p.directives:\n                continue\n            logger.debug(\"[{}] Adding directives: {}\".format(\n                p.template, p.directives))\n            resources += self._get_resources_string(p.directives, p.pid)\n            containers += self._get_container_string(p.directives, p.pid)\n        manifest = self._get_manifest_string()\n        self.resources = self._render_config(\"resources.config\", {\n            \"process_info\": resources\n        })\n        self.containers = self._render_config(\"containers.config\", {\n            \"container_info\": containers\n        })\n        self.params = self._render_config(\"params.config\", {\n            \"params_info\": params\n        })\n        self.manifest = self._render_config(\"manifest.config\", {\n            \"manifest_info\": manifest\n        })\n        self.help = self._render_config(\"Helper.groovy\", {\n            \"nf_file\": basename(self.nf_file),\n            \"help_list\": help_list,\n            \"version\": __version__,\n            \"pipeline_name\": \" \".join([x.upper() for x in self.pipeline_name])\n        })\n        self.user_config = self._render_config(\"user.config\", {})"
    },
    {
        "code": "def add_range(self, sequence, begin, end):\n    sequence.parser_tree = parsing.Range(self.value(begin).strip(\"'\"),\n                                         self.value(end).strip(\"'\"))\n    return True"
    },
    {
        "code": "def streams(self):\n        result = self.db.read(self.path, {\"q\": \"ls\"})\n        if result is None or result.json() is None:\n            return []\n        streams = []\n        for s in result.json():\n            strm = self[s[\"name\"]]\n            strm.metadata = s\n            streams.append(strm)\n        return streams"
    },
    {
        "code": "def truncate_string(data, headers, max_field_width=None, **_):\n    return (([utils.truncate_string(v, max_field_width) for v in row] for row in data),\n            [utils.truncate_string(h, max_field_width) for h in headers])"
    },
    {
        "code": "def login(self):\n        if self._session is None:\n            self._session = requests.session()\n            self._session.headers.update({'User-agent': str(UserAgent().random)})\n        return self._post_login_page()"
    },
    {
        "code": "def file_read(filename):\n    fobj = open(filename,'r');\n    source = fobj.read();\n    fobj.close()\n    return source"
    },
    {
        "code": "def einsum_vecmul_index(gate_indices, number_of_qubits):\n    mat_l, mat_r, tens_lin, tens_lout = _einsum_matmul_index_helper(gate_indices,\n                                                                    number_of_qubits)\n    return \"{mat_l}{mat_r}, \".format(mat_l=mat_l, mat_r=mat_r) + \\\n           \"{tens_lin}->{tens_lout}\".format(tens_lin=tens_lin,\n                                            tens_lout=tens_lout)"
    },
    {
        "code": "def validate_widget(widget):\n    if not has_valid_id(widget):\n        raise InvalidWidget(\"%s must contain a valid 'id' attribute\" % widget.__name__)\n    if not has_valid_name(widget):\n        raise InvalidWidget(\"%s must contain a valid 'name' attribute\" % widget.__name__)\n    if not has_valid_template(widget):\n        raise InvalidWidget(\"%s must contain a valid 'template' attribute\" % widget.__name__)\n    if not hasattr(widget, 'zones') or not widget.zones:\n        raise InvalidWidget(\"%s must be compatible with at least one zone\" % widget.__name__)"
    },
    {
        "code": "def institute(context, institute_id, sanger_recipient, coverage_cutoff, frequency_cutoff, \n              display_name, remove_sanger):\n    adapter = context.obj['adapter']\n    LOG.info(\"Running scout update institute\")\n    try:\n        adapter.update_institute(\n            internal_id=institute_id, \n            sanger_recipient=sanger_recipient, \n            coverage_cutoff=coverage_cutoff, \n            frequency_cutoff=frequency_cutoff, \n            display_name=display_name,\n            remove_sanger=remove_sanger,\n            )\n    except Exception as err:\n        LOG.warning(err)\n        context.abort()"
    },
    {
        "code": "def get_agency_id(relation):\n    op = relation.tags.get('operator')\n    if op:\n        return int(hashlib.sha256(op.encode('utf-8')).hexdigest(), 16) % 10**8\n    return -1"
    },
    {
        "code": "def writes(nb, format, **kwargs):\n    format = unicode(format)\n    if format == u'json' or format == u'ipynb':\n        return writes_json(nb, **kwargs)\n    elif format == u'py':\n        return writes_py(nb, **kwargs)\n    else:\n        raise NBFormatError('Unsupported format: %s' % format)"
    },
    {
        "code": "def f_add_config_group(self, *args, **kwargs):\n        return self._nn_interface._add_generic(self, type_name=CONFIG_GROUP,\n                                               group_type_name=CONFIG_GROUP,\n                                               args=args, kwargs=kwargs)"
    },
    {
        "code": "def _get_authorization(self, request, httpclient):\n        return 'WRAP access_token=\"' + \\\n                self._get_token(request.host, request.path, httpclient) + '\"'"
    },
    {
        "code": "def evaluate(self, expression, i1=None, i2=None, out=None, selection=None, delay=False):\n        expression = _ensure_strings_from_expressions(expression)\n        result = self.server._call_dataset(\"evaluate\", self, expression=expression, i1=i1, i2=i2, selection=selection, delay=delay)\n        return result"
    },
    {
        "code": "def _get_value(self, key, func=None, split_val=None, as_boolean=False,\n\t\texception_default=None):\n\t\ttry:\n\t\t\tif as_boolean:\n\t\t\t\treturn self.config.getboolean(key[0], key[1])\n\t\t\tvalue = self.config.get(key[0], key[1])\n\t\t\tif split_val is not None:\n\t\t\t\tvalue = value.split(split_val)\n\t\t\tif func is not None:\n\t\t\t\treturn func(value)\n\t\t\treturn value\n\t\texcept (KeyError, configparser.NoSectionError, configparser.NoOptionError) as e:\n\t\t\tif exception_default is not None:\n\t\t\t\treturn exception_default\n\t\t\traise KeyError(e)"
    },
    {
        "code": "def get_system_cpu_times():\n    user, system, idle = 0, 0, 0\n    for cpu_time in _psutil_mswindows.get_system_cpu_times():\n        user += cpu_time[0]\n        system += cpu_time[1]\n        idle += cpu_time[2]\n    return _cputimes_ntuple(user, system, idle)"
    },
    {
        "code": "def _spark_fit(self, cls, Z, *args, **kwargs):\n        mapper = lambda X_y: super(cls, self).fit(\n            X_y[0], X_y[1], *args, **kwargs\n        )\n        models = Z.map(mapper)\n        avg = models.reduce(operator.add) / models.count()\n        self.__dict__.update(avg.__dict__)\n        return self"
    },
    {
        "code": "def main(sample_id, assembly_file, coverage_file, coverage_bp_file, bam_file,\n         opts, gsize):\n    min_assembly_coverage, max_contigs = opts\n    logger.info(\"Starting assembly mapping processing\")\n    logger.info(\"Parsing coverage table\")\n    coverage_info, a_cov = parse_coverage_table(coverage_file)\n    a_size, contig_size = get_assembly_size(assembly_file)\n    logger.info(\"Assembly processed with a total size of '{}' and coverage\"\n                \" of '{}'\".format(a_size, a_cov))\n    logger.info(\"Parsing coverage per bp table\")\n    coverage_bp_data = get_coverage_from_file(coverage_bp_file)\n    min_coverage = evaluate_min_coverage(min_assembly_coverage, a_cov, a_size)\n    filtered_assembly = \"{}_filt.fasta\".format(\n        os.path.splitext(assembly_file)[0])\n    filtered_bam = \"filtered.bam\"\n    logger.info(\"Checking filtered assembly\")\n    if check_filtered_assembly(coverage_info, coverage_bp_data, min_coverage,\n                               gsize, contig_size, int(max_contigs),\n                               sample_id):\n        logger.info(\"Filtered assembly passed minimum size threshold\")\n        logger.info(\"Writting filtered assembly\")\n        filter_assembly(assembly_file, min_coverage, coverage_info,\n                        filtered_assembly)\n        logger.info(\"Filtering BAM file according to saved contigs\")\n        filter_bam(coverage_info, bam_file, min_coverage, filtered_bam)\n    else:\n        shutil.copy(assembly_file, filtered_assembly)\n        shutil.copy(bam_file, filtered_bam)\n        shutil.copy(bam_file + \".bai\", filtered_bam + \".bai\")\n    with open(\".status\", \"w\") as status_fh:\n        status_fh.write(\"pass\")"
    },
    {
        "code": "def fetchmany(self, size=None):\n        self._check_executed()\n        r = self._fetch_row(size or self.arraysize)\n        self.rownumber = self.rownumber + len(r)\n        if not r:\n            self._warning_check()\n        return r"
    },
    {
        "code": "def find_source(self, filename):\n        source = None\n        base, ext = os.path.splitext(filename)\n        TRY_EXTS = {\n            '.py':  ['.py', '.pyw'],\n            '.pyw': ['.pyw'],\n        }\n        try_exts = TRY_EXTS.get(ext)\n        if not try_exts:\n            return filename, None\n        for try_ext in try_exts:\n            try_filename = base + try_ext\n            if os.path.exists(try_filename):\n                return try_filename, None\n            source = self.coverage.file_locator.get_zip_data(try_filename)\n            if source:\n                return try_filename, source\n        raise NoSource(\"No source for code: '%s'\" % filename)"
    },
    {
        "code": "def get_document(self, document_id, database_name=None, collection_name=None):\n        if document_id is None:\n            raise AirflowBadRequest(\"Cannot get a document without an id\")\n        try:\n            return self.get_conn().ReadItem(\n                get_document_link(\n                    self.__get_database_name(database_name),\n                    self.__get_collection_name(collection_name),\n                    document_id))\n        except HTTPFailure:\n            return None"
    },
    {
        "code": "def execute_actions(self, cwd):\n        self._execute_globals(cwd)\n        for action in self.actions:\n            logger.info(\"executing {}\".format(action))\n            p = subprocess.Popen(action, shell=True, cwd=cwd)\n            p.wait()"
    },
    {
        "code": "def __var_find_to_py_ast(\n    var_name: str, ns_name: str, py_var_ctx: ast.AST\n) -> GeneratedPyAST:\n    return GeneratedPyAST(\n        node=ast.Attribute(\n            value=ast.Call(\n                func=_FIND_VAR_FN_NAME,\n                args=[\n                    ast.Call(\n                        func=_NEW_SYM_FN_NAME,\n                        args=[ast.Str(var_name)],\n                        keywords=[ast.keyword(arg=\"ns\", value=ast.Str(ns_name))],\n                    )\n                ],\n                keywords=[],\n            ),\n            attr=\"value\",\n            ctx=py_var_ctx,\n        )\n    )"
    },
    {
        "code": "def create_storage_account(self, service_name, description, label,\n                               affinity_group=None, location=None,\n                               geo_replication_enabled=None,\n                               extended_properties=None,\n                               account_type='Standard_GRS'):\n        _validate_not_none('service_name', service_name)\n        _validate_not_none('description', description)\n        _validate_not_none('label', label)\n        if affinity_group is None and location is None:\n            raise ValueError(\n                'location or affinity_group must be specified')\n        if affinity_group is not None and location is not None:\n            raise ValueError(\n                'Only one of location or affinity_group needs to be specified')\n        if geo_replication_enabled == False:\n            account_type = 'Standard_LRS'\n        return self._perform_post(\n            self._get_storage_service_path(),\n            _XmlSerializer.create_storage_service_input_to_xml(\n                service_name,\n                description,\n                label,\n                affinity_group,\n                location,\n                account_type,\n                extended_properties),\n            as_async=True)"
    },
    {
        "code": "def set_selection(self, selection, name=\"default\", executor=None):\n        def create(current):\n            return selection\n        self._selection(create, name, executor=executor, execute_fully=True)"
    },
    {
        "code": "def set_resolved_name(self, ref: dict, type_name2solve: TypeName,\n                          type_name_ref: TypeName):\n        if self.resolution[type_name2solve.value] is None:\n            self.resolution[type_name2solve.value] = ref[type_name_ref.value]"
    },
    {
        "code": "def format_data(self, data, scale=True):\n        if len(self.analytes) == 1:\n            d = nominal_values(data[self.analytes[0]])\n            ds = np.array(list(zip(d, np.zeros(len(d)))))\n        else:\n            d = [nominal_values(data[a]) for a in self.analytes]\n            ds = np.vstack(d).T\n        finite = np.isfinite(ds).sum(1) == ds.shape[1]\n        sampled = np.arange(data[self.analytes[0]].size)[finite]\n        ds = ds[finite]\n        if scale:\n            ds = self.scaler.transform(ds)\n        return ds, sampled"
    },
    {
        "code": "def _referer(self, extension):\n        iana_record = self.lookup.whois(\n            PyFunceble.CONFIGURATION[\"iana_whois_server\"], \"hello.%s\" % extension\n        )\n        if iana_record and \"refer\" in iana_record:\n            regex_referer = r\"(?s)refer\\:\\s+([a-zA-Z0-9._-]+)\\n\"\n            matched = Regex(\n                iana_record, regex_referer, return_data=True, group=1\n            ).match()\n            if matched:\n                return matched\n        if extension in self.manual_server:\n            return self.manual_server[extension]\n        return None"
    },
    {
        "code": "def shape_rb_data(raw_rb):\n    rb_data = []\n    rb_data.append(np.mean(raw_rb, 0))\n    rb_data.append(np.std(raw_rb, 0))\n    return rb_data"
    },
    {
        "code": "def update_function(self, name, body, update_mask):\n        response = self.get_conn().projects().locations().functions().patch(\n            updateMask=\",\".join(update_mask),\n            name=name,\n            body=body\n        ).execute(num_retries=self.num_retries)\n        operation_name = response[\"name\"]\n        self._wait_for_operation_to_complete(operation_name=operation_name)"
    },
    {
        "code": "def boolean(ctx, obj):\n    if hasattr(obj, 'compute'):\n        obj = next(seq.compute(ctx), '')\n    else:\n        obj = seq\n    yield next(to_boolean(obj), '')"
    },
    {
        "code": "def expects_none(options):\n    if any(options.get(key) is not None for key in [\"count\", \"maximum\", \"minimum\", \"between\"]):\n        return matches_count(0, options)\n    else:\n        return False"
    },
    {
        "code": "def __early_downsample(y, sr, hop_length, res_type, n_octaves,\n                       nyquist, filter_cutoff, scale):\n    downsample_count = __early_downsample_count(nyquist, filter_cutoff,\n                                                hop_length, n_octaves)\n    if downsample_count > 0 and res_type == 'kaiser_fast':\n        downsample_factor = 2**(downsample_count)\n        hop_length //= downsample_factor\n        if len(y) < downsample_factor:\n            raise ParameterError('Input signal length={:d} is too short for '\n                                 '{:d}-octave CQT'.format(len(y), n_octaves))\n        new_sr = sr / float(downsample_factor)\n        y = audio.resample(y, sr, new_sr,\n                           res_type=res_type,\n                           scale=True)\n        if not scale:\n            y *= np.sqrt(downsample_factor)\n        sr = new_sr\n    return y, sr, hop_length"
    },
    {
        "code": "def log_parser(self):\n        size_stamp = os.path.getsize(self.log_file)\n        self.log_retry = 0\n        if size_stamp and size_stamp == self.log_sizestamp:\n            return\n        else:\n            logger.debug(\"Updating log size stamp to: {}\".format(size_stamp))\n            self.log_sizestamp = size_stamp\n        r = \".* (.*) \\[.*\\].*\\[(.*)\\].*process > (.*) \\((.*)\\).*\"\n        with open(self.log_file) as fh:\n            for line in fh:\n                if \"Submitted process >\" in line or \\\n                        \"Re-submitted process >\" in line or \\\n                        \"Cached process >\" in line:\n                    m = re.match(r, line)\n                    if not m:\n                        continue\n                    time_start = m.group(1)\n                    workdir = m.group(2)\n                    process = m.group(3)\n                    tag = m.group(4)\n                    if time_start + tag not in self.stored_log_ids:\n                        self.stored_log_ids.append(time_start + tag)\n                    else:\n                        continue\n                    if process not in self.processes:\n                        continue\n                    p = self.processes[process]\n                    if tag in list(p[\"finished\"]) + list(p[\"retry\"]):\n                        continue\n                    if tag in list(p[\"failed\"]) and \\\n                            \"Re-submitted process >\" in line:\n                        p[\"retry\"].add(tag)\n                        self.send = True\n                        continue\n                    p[\"barrier\"] = \"R\"\n                    if tag not in p[\"submitted\"]:\n                        p[\"submitted\"].add(tag)\n                        if tag not in self.process_tags[process]:\n                            self.process_tags[process][tag] = {\n                                \"workdir\": self._expand_path(workdir),\n                                \"start\": time_start\n                            }\n                            self.send = True\n                        elif not self.process_tags[process][tag][\"start\"]:\n                            self.process_tags[process][tag][\"start\"] = time_start\n                            self.send = True\n        self._update_pipeline_status()"
    },
    {
        "code": "def _remove_exploration(self):\n        for param in self._explored_parameters.values():\n            if param._stored:\n                try:\n                    self.f_delete_item(param)\n                except Exception:\n                    self._logger.exception('Could not delete expanded parameter `%s` '\n                                           'from disk.' % param.v_full_name)"
    },
    {
        "code": "def setup_platform(hass, config, add_entities, discovery_info=None):\n    host = config.get(CONF_HOST)\n    token = config.get(CONF_ACCESS_TOKEN)\n    name = config.get(CONF_NAME)\n    volume_step = config.get(CONF_VOLUME_STEP)\n    device_type = config.get(CONF_DEVICE_CLASS)\n    device = VizioDevice(host, token, name, volume_step, device_type)\n    if device.validate_setup() is False:\n        _LOGGER.error(\"Failed to set up Vizio platform, \"\n                      \"please check if host and API key are correct\")\n        return\n    elif (token is None or token == \"\") and device_type == \"tv\":\n        _LOGGER.error(\"Failed to set up Vizio platform, \"\n                      \"if device_class is 'tv' then an auth_token needs \"\n                      \"to be provided, otherwise if device_class is \"\n                      \"'soundbar' then add the right device_class to config\")\n        return\n    if config.get(CONF_SUPPRESS_WARNING):\n        from requests.packages import urllib3\n        _LOGGER.warning(\"InsecureRequestWarning is disabled \"\n                        \"because of Vizio platform configuration\")\n        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\n    add_entities([device], True)"
    },
    {
        "code": "def handle_oauth2_response(self, args):\n        client = self.make_client()\n        remote_args = {\n            'code': args.get('code'),\n            'client_secret': self.consumer_secret,\n            'redirect_uri': session.get('%s_oauthredir' % self.name)\n        }\n        log.debug('Prepare oauth2 remote args %r', remote_args)\n        remote_args.update(self.access_token_params)\n        headers = copy(self._access_token_headers)\n        if self.access_token_method == 'POST':\n            headers.update({'Content-Type': 'application/x-www-form-urlencoded'})\n            body = client.prepare_request_body(**remote_args)\n            resp, content = self.http_request(\n                self.expand_url(self.access_token_url),\n                headers=headers,\n                data=to_bytes(body, self.encoding),\n                method=self.access_token_method,\n            )\n        elif self.access_token_method == 'GET':\n            qs = client.prepare_request_body(**remote_args)\n            url = self.expand_url(self.access_token_url)\n            url += ('?' in url and '&' or '?') + qs\n            resp, content = self.http_request(\n                url,\n                headers=headers,\n                method=self.access_token_method,\n            )\n        else:\n            raise OAuthException(\n                'Unsupported access_token_method: %s' %\n                self.access_token_method\n            )\n        data = parse_response(resp, content, content_type=self.content_type)\n        if resp.code not in (200, 201):\n            raise OAuthException(\n                'Invalid response from %s' % self.name,\n                type='invalid_response', data=data\n            )\n        return data"
    },
    {
        "code": "def decode(self, val):\n    new_val = self.decode_date(val)\n    if val != new_val:\n      return new_val\n    return json.JSONDecoder.decode(self, val)"
    },
    {
        "code": "def extractPrintSaveIntermittens():\n    global g_summary_dict_intermittents\n    localtz = time.tzname[0]\n    for ind in range(len(g_summary_dict_all[\"TestName\"])):\n        if g_summary_dict_all[\"TestInfo\"][ind][\"FailureCount\"] >= g_threshold_failure:\n            addFailedTests(g_summary_dict_intermittents, g_summary_dict_all, ind)\n    if len(g_summary_dict_intermittents[\"TestName\"]) > 0:\n        json.dump(g_summary_dict_intermittents, open(g_summary_dict_name, 'w'))\n        with open(g_summary_csv_filename, 'w') as summaryFile:\n            for ind in range(len(g_summary_dict_intermittents[\"TestName\"])):\n                testName = g_summary_dict_intermittents[\"TestName\"][ind]\n                numberFailure = g_summary_dict_intermittents[\"TestInfo\"][ind][\"FailureCount\"]\n                firstFailedTS  = parser.parse(time.ctime(min(g_summary_dict_intermittents[\"TestInfo\"][ind][\"Timestamp\"]))+\n                                              ' '+localtz)\n                firstFailedStr = firstFailedTS.strftime(\"%a %b %d %H:%M:%S %Y %Z\")\n                recentFail = parser.parse(time.ctime(max(g_summary_dict_intermittents[\"TestInfo\"][ind][\"Timestamp\"]))+\n                                          ' '+localtz)\n                recentFailStr = recentFail.strftime(\"%a %b %d %H:%M:%S %Y %Z\")\n                eachTest = \"{0}, {1}, {2}, {3}\\n\".format(testName, recentFailStr, numberFailure,\n                                                       g_summary_dict_intermittents[\"TestInfo\"][ind][\"TestCategory\"][0])\n                summaryFile.write(eachTest)\n                print(\"Intermittent: {0}, Last failed: {1}, Failed {2} times since \"\n                      \"{3}\".format(testName, recentFailStr, numberFailure, firstFailedStr))"
    },
    {
        "code": "def _get_rule_source(self, rule):\n    p = len(self.input_source) + rule.position\n    source = self.input_source[p:p + rule.consumed].rstrip()\n    return self._indent(source, depth=self.indent + \"   \", skip_first_line=True)"
    },
    {
        "code": "def _resubscribe(self, soft=False):\n        if self.bitfinex_config:\n            self.send(**self.bitfinex_config)\n        q_list = []\n        while True:\n            try:\n                identifier, q = self.channel_configs.popitem(last=True if soft else False)\n            except KeyError:\n                break\n            q_list.append((identifier, q.copy()))\n            if identifier == 'auth':\n                self.send(**q, auth=True)\n                continue\n            if soft:\n                q['event'] = 'unsubscribe'\n            self.send(**q)\n        if soft:\n            for identifier, q in reversed(q_list):\n                self.channel_configs[identifier] = q\n                self.send(**q)\n        else:\n            for identifier, q in q_list:\n                self.channel_configs[identifier] = q"
    },
    {
        "code": "def _receive_data(self):\n        while True:\n            while len(self._buffer) < self.max_size and self.conn.poll():\n                data = self._read_chunks()\n                if data is not None:\n                    self._buffer.append(data)\n            if len(self._buffer) > 0:\n                return self._buffer.popleft()"
    },
    {
        "code": "def _build_purchase_item(course_id, course_url, cost_in_cents, mode, course_data, sku):\n    item = {\n        'id': \"{}-{}\".format(course_id, mode),\n        'url': course_url,\n        'price': cost_in_cents,\n        'qty': 1,\n    }\n    if 'title' in course_data:\n        item['title'] = course_data['title']\n    else:\n        item['title'] = 'Course {} mode: {}'.format(course_id, mode)\n    if 'tags' in course_data:\n        item['tags'] = course_data['tags']\n    item['vars'] = dict(course_data.get('vars', {}), mode=mode, course_run_id=course_id)\n    item['vars']['purchase_sku'] = sku\n    return item"
    },
    {
        "code": "def _vector_matrix(vs, ms):\n  return tf.reduce_sum(input_tensor=vs[..., tf.newaxis] * ms, axis=-2)"
    },
    {
        "code": "def mix_over_posterior_draws(means, variances):\n  with tf.compat.v1.name_scope(\n      'mix_over_posterior_draws', values=[means, variances]):\n    num_posterior_draws = dist_util.prefer_static_value(\n        tf.shape(input=means))[0]\n    component_observations = tfd.Independent(\n        distribution=tfd.Normal(\n            loc=dist_util.move_dimension(means, 0, -2),\n            scale=tf.sqrt(dist_util.move_dimension(variances, 0, -2))),\n        reinterpreted_batch_ndims=1)\n    return tfd.MixtureSameFamily(\n        mixture_distribution=tfd.Categorical(\n            logits=tf.zeros([num_posterior_draws],\n                            dtype=component_observations.dtype)),\n        components_distribution=component_observations)"
    },
    {
        "code": "def DeleteItem(self, item):\r\n        \"Remove the item from the list and unset the related data\"\r\n        wx_data = self.GetItemData(item)\r\n        py_data = self._py_data_map[wx_data]\r\n        del self._py_data_map[wx_data]\r\n        del self._wx_data_map[py_data]\r\n        wx.ListCtrl.DeleteItem(self, item)"
    },
    {
        "code": "def add_route(self, command, adapter):\n        if not isinstance(adapter, BaseAdapter):\n            try:\n                adapter = self.adapter_aliases[adapter]\n            except KeyError:\n                self.adapter_aliases[adapter] = adapter = resolve_adapter(\n                    adapter\n                )\n        self.routes[command] = adapter\n        return self"
    },
    {
        "code": "def progress(iterator, prefix):\n    if terminal_width(prefix) > 25:\n        prefix = (\"..\" + get_cut_prefix(prefix, 23))\n    speed_updated = start = time()\n    speed_written = written = 0\n    speed_history = deque(maxlen=5)\n    for data in iterator:\n        yield data\n        now = time()\n        elapsed = now - start\n        written += len(data)\n        speed_elapsed = now - speed_updated\n        if speed_elapsed >= 0.5:\n            speed_history.appendleft((\n                written - speed_written,\n                speed_updated,\n            ))\n            speed_updated = now\n            speed_written = written\n            speed_history_written = sum(h[0] for h in speed_history)\n            speed_history_elapsed = now - speed_history[-1][1]\n            speed = speed_history_written / speed_history_elapsed\n            status = create_status_line(\n                prefix=prefix,\n                written=format_filesize(written),\n                elapsed=format_time(elapsed),\n                speed=format_filesize(speed)\n            )\n            print_inplace(status)\n    sys.stderr.write(\"\\n\")\n    sys.stderr.flush()"
    },
    {
        "code": "def get_params(brightness, contrast, saturation, hue):\n        transforms = []\n        if brightness is not None:\n            brightness_factor = random.uniform(brightness[0], brightness[1])\n            transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor)))\n        if contrast is not None:\n            contrast_factor = random.uniform(contrast[0], contrast[1])\n            transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))\n        if saturation is not None:\n            saturation_factor = random.uniform(saturation[0], saturation[1])\n            transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor)))\n        if hue is not None:\n            hue_factor = random.uniform(hue[0], hue[1])\n            transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor)))\n        random.shuffle(transforms)\n        transform = Compose(transforms)\n        return transform"
    },
    {
        "code": "def panel(context, panel, version, update_date, update_version):\n    adapter = context.obj['adapter']\n    panel_obj = adapter.gene_panel(panel, version=version)\n    if not panel_obj:\n        LOG.warning(\"Panel %s (version %s) could not be found\" % (panel, version))\n        context.abort()\n    date_obj = None\n    if update_date:\n        try:\n            date_obj = get_date(update_date)\n        except Exception as err:\n            LOG.warning(err)\n            context.abort()\n    update_panel(\n        adapter,\n        panel,\n        panel_version=panel_obj['version'],\n        new_version=update_version,\n        new_date=date_obj\n    )"
    },
    {
        "code": "def random_ports(port, n):\n    for i in range(min(5, n)):\n        yield port + i\n    for i in range(n-5):\n        yield port + random.randint(-2*n, 2*n)"
    },
    {
        "code": "def PermissiveDict(fields=None):\n    if fields:\n        check_user_facing_fields_dict(fields, 'PermissiveDict')\n    class _PermissiveDict(_ConfigComposite):\n        def __init__(self):\n            key = 'PermissiveDict.' + str(DictCounter.get_next_count())\n            super(_PermissiveDict, self).__init__(\n                name=None,\n                key=key,\n                fields=fields or dict(),\n                description='A configuration dictionary with typed fields',\n                type_attributes=ConfigTypeAttributes(is_builtin=True),\n            )\n        @property\n        def is_permissive_composite(self):\n            return True\n    return _PermissiveDict"
    },
    {
        "code": "def gravatar_url(user_or_email, size=GRAVATAR_DEFAULT_SIZE):\n    if hasattr(user_or_email, 'email'):\n        email = user_or_email.email\n    else:\n        email = user_or_email\n    try:\n        return escape(get_gravatar_url(email=email, size=size))\n    except:\n        return ''"
    },
    {
        "code": "def run_as_cmd(cmd, user, shell='bash'):\n    to_execute = get_shell(shell) + [EXECUTE_SHELL_PARAM, cmd]\n    if user == 'root':\n        return to_execute\n    return ['sudo', '-s', '--set-home', '-u', user] + to_execute"
    },
    {
        "code": "def profile_function(self):\n        with _CodeHeatmapCalculator() as prof:\n            result = self._run_object(*self._run_args, **self._run_kwargs)\n        code_lines, start_line = inspect.getsourcelines(self._run_object)\n        source_lines = []\n        for line in code_lines:\n            source_lines.append(('line', start_line, line))\n            start_line += 1\n        filename = os.path.abspath(inspect.getsourcefile(self._run_object))\n        heatmap = prof.heatmap[filename]\n        run_time = sum(time for time in heatmap.values())\n        return {\n            'objectName': self._object_name,\n            'runTime': run_time,\n            'result': result,\n            'timestamp': int(time.time()),\n            'heatmaps': [{\n                'name': self._object_name,\n                'heatmap': heatmap,\n                'executionCount': prof.execution_count[filename],\n                'srcCode': source_lines,\n                'runTime': run_time\n            }]\n        }"
    },
    {
        "code": "def dashboard(request):\n    if not isinstance(mc_client, dict):\n        cache_stats = _get_cache_stats()\n    else:\n        cache_stats = None\n    if cache_stats:\n        data = _context_data({\n            'title': _('Memcache Dashboard'),\n            'cache_stats': cache_stats,\n            'can_get_slabs': hasattr(mc_client, 'get_slabs'),\n            'REFRESH_RATE': SETTINGS['REFRESH_RATE'],\n        },\n            request)\n        template = 'memcache_admin/dashboard.html'\n    else:\n        data = _context_data({\n            'title': _('Memcache Dashboard - Error'),\n            'error_message': _('Unable to connect to a memcache server.'),\n        },\n            request)\n        template = 'memcache_admin/dashboard_error.html'\n    return render_to_response(template, data, RequestContext(request))"
    },
    {
        "code": "def _validate_initial_statevector(self):\n        if self._initial_statevector is None:\n            return\n        length = len(self._initial_statevector)\n        required_dim = 2 ** self._number_of_qubits\n        if length != required_dim:\n            raise BasicAerError('initial statevector is incorrect length: ' +\n                                '{} != {}'.format(length, required_dim))"
    },
    {
        "code": "def chatToId(url):\n        match = re.search(r\"conversations/([0-9]+:[^/]+)\", url)\n        return match.group(1) if match else None"
    },
    {
        "code": "def prepare_pids(self):\n        self.pids = []\n        for fetcher in self.pid_fetchers:\n            val = fetcher(None, self.revisions[-1][1])\n            if val:\n                self.pids.append(val)"
    },
    {
        "code": "def use(network=False):\n    global _engine\n    __engine = _engine\n    activated = __engine.active\n    if activated:\n        __engine.disable()\n    _engine = Engine(network=network)\n    _engine.activate()\n    yield _engine\n    _engine.disable()\n    if network:\n        _engine.disable_network()\n    _engine = __engine\n    if activated:\n        _engine.activate()"
    },
    {
        "code": "def parse_yaml_linenumbers(data, filename):\n    def compose_node(parent, index):\n        line = loader.line\n        node = Composer.compose_node(loader, parent, index)\n        node.__line__ = line + 1\n        return node\n    def construct_mapping(node, deep=False):\n        if ANSIBLE_VERSION < 2:\n            mapping = Constructor.construct_mapping(loader, node, deep=deep)\n        else:\n            mapping = AnsibleConstructor.construct_mapping(loader, node, deep=deep)\n        if hasattr(node, '__line__'):\n            mapping[LINE_NUMBER_KEY] = node.__line__\n        else:\n            mapping[LINE_NUMBER_KEY] = mapping._line_number\n        mapping[FILENAME_KEY] = filename\n        return mapping\n    try:\n        if ANSIBLE_VERSION < 2:\n            loader = yaml.Loader(data)\n        else:\n            import inspect\n            kwargs = {}\n            if 'vault_password' in inspect.getargspec(AnsibleLoader.__init__).args:\n                kwargs['vault_password'] = DEFAULT_VAULT_PASSWORD\n            loader = AnsibleLoader(data, **kwargs)\n        loader.compose_node = compose_node\n        loader.construct_mapping = construct_mapping\n        data = loader.get_single_data()\n    except (yaml.parser.ParserError, yaml.scanner.ScannerError) as e:\n        raise SystemExit(\"Failed to parse YAML in %s: %s\" % (filename, str(e)))\n    return data"
    },
    {
        "code": "def log_cdf_laplace(x, name=\"log_cdf_laplace\"):\n  with tf.name_scope(name):\n    x = tf.convert_to_tensor(value=x, name=\"x\")\n    lower_solution = -np.log(2.) + x\n    safe_exp_neg_x = tf.exp(-tf.abs(x))\n    upper_solution = tf.math.log1p(-0.5 * safe_exp_neg_x)\n    return tf.where(x < 0., lower_solution, upper_solution)"
    },
    {
        "code": "def samefile(path1, path2):\n    info1 = fs.getfileinfo(path1)\n    info2 = fs.getfileinfo(path2)\n    return (info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber and\n            info1.nFileIndexHigh == info2.nFileIndexHigh and\n            info1.nFileIndexLow == info2.nFileIndexLow)"
    },
    {
        "code": "def add_netnode_plugin_name(plugin_name):\n    current_names = set(get_netnode_plugin_names())\n    if plugin_name in current_names:\n        return\n    current_names.add(plugin_name)\n    get_meta_netnode()[PLUGIN_NAMES_KEY] = json.dumps(list(current_names))"
    },
    {
        "code": "def set_serial(self, hex_str):\n        bignum_serial = _ffi.gc(_lib.BN_new(), _lib.BN_free)\n        bignum_ptr = _ffi.new(\"BIGNUM**\")\n        bignum_ptr[0] = bignum_serial\n        bn_result = _lib.BN_hex2bn(bignum_ptr, hex_str)\n        if not bn_result:\n            raise ValueError(\"bad hex string\")\n        asn1_serial = _ffi.gc(\n            _lib.BN_to_ASN1_INTEGER(bignum_serial, _ffi.NULL),\n            _lib.ASN1_INTEGER_free)\n        _lib.X509_REVOKED_set_serialNumber(self._revoked, asn1_serial)"
    },
    {
        "code": "def run_samblaster(job, sam):\n    work_dir = job.fileStore.getLocalTempDir()\n    job.fileStore.readGlobalFile(sam, os.path.join(work_dir, 'input.sam'))\n    command = ['/usr/local/bin/samblaster',\n               '-i', '/data/input.sam',\n               '-o', '/data/output.sam',\n               '--ignoreUnmated']\n    start_time = time.time()\n    dockerCall(job=job, workDir=work_dir,\n               parameters=command,\n               tool='quay.io/biocontainers/samblaster:0.1.24--0')\n    end_time = time.time()\n    _log_runtime(job, start_time, end_time, \"SAMBLASTER\")\n    return job.fileStore.writeGlobalFile(os.path.join(work_dir, 'output.sam'))"
    },
    {
        "code": "def handle_stranded_tasks(self, engine):\n        lost = self.pending[engine]\n        for msg_id in lost.keys():\n            if msg_id not in self.pending[engine]:\n                continue\n            raw_msg = lost[msg_id].raw_msg\n            idents,msg = self.session.feed_identities(raw_msg, copy=False)\n            parent = self.session.unpack(msg[1].bytes)\n            idents = [engine, idents[0]]\n            try:\n                raise error.EngineError(\"Engine %r died while running task %r\"%(engine, msg_id))\n            except:\n                content = error.wrap_exception()\n            header = dict(\n                status='error',\n                engine=engine,\n                date=datetime.now(),\n            )\n            msg = self.session.msg('apply_reply', content, parent=parent, subheader=header)\n            raw_reply = map(zmq.Message, self.session.serialize(msg, ident=idents))\n            self.dispatch_result(raw_reply)\n        self.completed.pop(engine)\n        self.failed.pop(engine)"
    },
    {
        "code": "def get_group_all(group, path=None):\n    result = []\n    for config, distro in iter_files_distros(path=path):\n        if group in config:\n            for name, epstr in config[group].items():\n                with BadEntryPoint.err_to_warnings():\n                    result.append(EntryPoint.from_string(epstr, name, distro))\n    return result"
    },
    {
        "code": "def build_filters_and_sizers(self, ppoi_value, create_on_demand):\n        name = self.name\n        if not name and self.field.placeholder_image_name:\n            name = self.field.placeholder_image_name\n        self.filters = FilterLibrary(\n            name,\n            self.storage,\n            versatileimagefield_registry,\n            ppoi_value,\n            create_on_demand\n        )\n        for (\n            attr_name,\n            sizedimage_cls\n        ) in iteritems(versatileimagefield_registry._sizedimage_registry):\n            setattr(\n                self,\n                attr_name,\n                sizedimage_cls(\n                    path_to_image=name,\n                    storage=self.storage,\n                    create_on_demand=create_on_demand,\n                    ppoi=ppoi_value\n                )\n            )"
    },
    {
        "code": "def predict_logit(self, x, **kwargs):\n        return self.feed_forward(x, **kwargs)[self.layers[-1].full_name('pre')]"
    },
    {
        "code": "def get_source_lane(fork_process, pipeline_list):\n    fork_source = fork_process[-1]\n    fork_sig = [x for x in fork_process if x != \"__init__\"]\n    for position, p in enumerate(pipeline_list[::-1]):\n        if p[\"output\"][\"process\"] == fork_source:\n            lane = p[\"output\"][\"lane\"]\n            logger.debug(\"Possible source match found in position {} in lane\"\n                         \" {}\".format(position, lane))\n            lane_sequence = [x[\"output\"][\"process\"] for x in pipeline_list\n                             if x[\"output\"][\"lane\"] == lane]\n            logger.debug(\"Testing lane sequence '{}' against fork signature\"\n                         \" '{}'\".format(lane_sequence, fork_sig))\n            if lane_sequence == fork_sig:\n                return p[\"output\"][\"lane\"]\n    return 0"
    },
    {
        "code": "def article(self, msgid_article=None, decode=None):\n        args = None\n        if msgid_article is not None:\n            args = utils.unparse_msgid_article(msgid_article)\n        code, message = self.command(\"ARTICLE\", args)\n        if code != 220:\n            raise NNTPReplyError(code, message)\n        parts = message.split(None, 1)\n        try:\n            articleno = int(parts[0])\n        except ValueError:\n            raise NNTPProtocolError(message)\n        headers = utils.parse_headers(self.info_gen(code, message))\n        decode = \"yEnc\" in headers.get(\"subject\", \"\")\n        escape = 0\n        crc32 = 0\n        body = []\n        for line in self.info_gen(code, message):\n            if decode:\n                if line.startswith(\"=y\"):\n                    continue\n                line, escape, crc32 = yenc.decode(line, escape, crc32)\n            body.append(line)\n        return articleno, headers, \"\".join(body)"
    },
    {
        "code": "def wrap_function(func=None, error_threshold=None, reraise_exception=True, save_current_stack_trace=True):\n    if func:\n        return flawless.client.client._wrap_function_with_error_decorator(\n            func=func,\n            error_threshold=error_threshold,\n            reraise_exception=reraise_exception,\n            save_current_stack_trace=save_current_stack_trace)\n    else:\n        return functools.partial(flawless.client.client._wrap_function_with_error_decorator,\n                                 error_threshold=error_threshold,\n                                 reraise_exception=reraise_exception,\n                                 save_current_stack_trace=save_current_stack_trace)"
    },
    {
        "code": "def post(self, url, params=None, data=None, files=None, **kwargs):\n        return self.call_api(\n            \"POST\",\n            url,\n            params=params,\n            data=data,\n            files=files,\n            **kwargs\n        )"
    },
    {
        "code": "def is_dark_rgb(r, g, b):\n    try:\n        midpoint = int(environ.get('TERMINAL_COLOR_MIDPOINT', None))\n    except:\n        pass\n    if not midpoint:\n        term = environ.get('TERM', None)\n        print(\"midpoint\", midpoint, 'vs',  (16*5 + 16*g + 16*b))\n        midpoint = 383 if term and term == 'xterm-256color' else 117963\n    if ( (16*5 + 16*g + 16*b) < midpoint ):\n        return True\n    else:\n        return False"
    },
    {
        "code": "def stop(self):\n        with self.synclock:\n            if self.syncthread is not None:\n                self.syncthread.cancel()\n                self.syncthread = None"
    },
    {
        "code": "def evaluate_marker(cls, text, extra=None):\n        return cls.interpret(parser.expr(text).totuple(1)[1])"
    },
    {
        "code": "def _get_job(self, project_id, job_id):\n        job_name = 'projects/{}/jobs/{}'.format(project_id, job_id)\n        request = self._mlengine.projects().jobs().get(name=job_name)\n        while True:\n            try:\n                return request.execute()\n            except HttpError as e:\n                if e.resp.status == 429:\n                    time.sleep(30)\n                else:\n                    self.log.error('Failed to get MLEngine job: {}'.format(e))\n                    raise"
    },
    {
        "code": "def pause(self):\n        for tracer in self.tracers:\n            tracer.stop()\n            stats = tracer.get_stats()\n            if stats:\n                print(\"\\nCoverage.py tracer stats:\")\n                for k in sorted(stats.keys()):\n                    print(\"%16s: %s\" % (k, stats[k]))\n        threading.settrace(None)"
    },
    {
        "code": "def to_py(o, keyword_fn: Callable[[kw.Keyword], Any] = _kw_name):\n    if isinstance(o, ISeq):\n        return _to_py_list(o, keyword_fn=keyword_fn)\n    elif not isinstance(\n        o, (IPersistentList, IPersistentMap, IPersistentSet, IPersistentVector)\n    ):\n        return o\n    else:\n        return _to_py_backup(o, keyword_fn=keyword_fn)"
    },
    {
        "code": "def indent(instr,nspaces=4, ntabs=0, flatten=False):\n    if instr is None:\n        return\n    ind = '\\t'*ntabs+' '*nspaces\n    if flatten:\n        pat = re.compile(r'^\\s*', re.MULTILINE)\n    else:\n        pat = re.compile(r'^', re.MULTILINE)\n    outstr = re.sub(pat, ind, instr)\n    if outstr.endswith(os.linesep+ind):\n        return outstr[:-len(ind)]\n    else:\n        return outstr"
    },
    {
        "code": "def handleCONNACK(self, response):\n        state = self.__class__.__name__\n        log.error(\"Unexpected {packet:7} packet received in {log_source}\", packet=\"CONNACK\")"
    },
    {
        "code": "def filter_bam(coverage_info, bam_file, min_coverage, output_bam):\n    contig_list = [x for x, vals in coverage_info.items()\n                   if vals[\"cov\"] >= min_coverage]\n    cli = [\n        \"samtools\",\n        \"view\",\n        \"-bh\",\n        \"-F\",\n        \"4\",\n        \"-o\",\n        output_bam,\n        \"-@\",\n        \"1\",\n        bam_file,\n    ]\n    cli += contig_list\n    logger.debug(\"Runnig samtools view subprocess with command: {}\".format(\n        cli))\n    p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE)\n    stdout, stderr = p.communicate()\n    try:\n        stderr = stderr.decode(\"utf8\")\n        stdout = stdout.decode(\"utf8\")\n    except (UnicodeDecodeError, AttributeError):\n        stderr = str(stderr)\n        stdout = str(stdout)\n    logger.info(\"Finished samtools view subprocess with STDOUT:\\\\n\"\n                \"======================================\\\\n{}\".format(stdout))\n    logger.info(\"Fished samtools view subprocesswith STDERR:\\\\n\"\n                \"======================================\\\\n{}\".format(stderr))\n    logger.info(\"Finished samtools view with return code: {}\".format(\n        p.returncode))\n    if not p.returncode:\n        cli = [\n            \"samtools\",\n            \"index\",\n            output_bam\n        ]\n        logger.debug(\"Runnig samtools index subprocess with command: \"\n                     \"{}\".format(cli))\n        p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE)\n        stdout, stderr = p.communicate()\n        try:\n            stderr = stderr.decode(\"utf8\")\n            stdout = stdout.decode(\"utf8\")\n        except (UnicodeDecodeError, AttributeError):\n            stderr = str(stderr)\n            stdout = str(stdout)\n        logger.info(\"Finished samtools index subprocess with STDOUT:\\\\n\"\n                    \"======================================\\\\n{}\".format(\n            stdout))\n        logger.info(\"Fished samtools index subprocesswith STDERR:\\\\n\"\n                    \"======================================\\\\n{}\".format(\n            stderr))\n        logger.info(\"Finished samtools index with return code: {}\".format(\n            p.returncode))"
    },
    {
        "code": "def create_tfs_tfvc_client(url, token=None):\n    if token is None:\n        token = os.environ.get('TFS_API_TOKEN', None)\n    tfs_connection = create_tfs_connection(url, token)\n    tfs_tfvc_client = tfs_connection.get_client('vsts.tfvc.v4_1.tfvc_client.TfvcClient')\n    if tfs_tfvc_client is None:\n        msg = 'Unable to create TFS Git Client, failed to connect to TFS Enterprise (%s) with provided token.'\n        raise RuntimeError(msg, url)\n    return tfs_tfvc_client"
    },
    {
        "code": "def visualize_qualitative_analysis(inputs, model, samples=1, batch_size=3,\n                                   length=8):\n  average = lambda dist: tf.reduce_mean(\n      input_tensor=dist.mean(), axis=0)\n  with tf.compat.v1.name_scope(\"val_reconstruction\"):\n    reconstruct = functools.partial(model.reconstruct, inputs=inputs,\n                                    samples=samples)\n    visualize_reconstruction(inputs, average(reconstruct()))\n    visualize_reconstruction(inputs, average(reconstruct(sample_static=True)),\n                             name=\"static_prior\")\n    visualize_reconstruction(inputs, average(reconstruct(sample_dynamic=True)),\n                             name=\"dynamic_prior\")\n    visualize_reconstruction(inputs, average(reconstruct(swap_static=True)),\n                             name=\"swap_static\")\n    visualize_reconstruction(inputs, average(reconstruct(swap_dynamic=True)),\n                             name=\"swap_dynamic\")\n  with tf.compat.v1.name_scope(\"generation\"):\n    generate = functools.partial(model.generate, batch_size=batch_size,\n                                 length=length, samples=samples)\n    image_summary(average(generate(fix_static=True)), \"fix_static\")\n    image_summary(average(generate(fix_dynamic=True)), \"fix_dynamic\")"
    },
    {
        "code": "def debug_script(src, pm=False, globs=None):\n    \"Debug a test script.  `src` is the script, as a string.\"\n    import pdb\n    srcfilename = tempfile.mktemp(\".py\", \"doctestdebug\")\n    f = open(srcfilename, 'w')\n    f.write(src)\n    f.close()\n    try:\n        if globs:\n            globs = globs.copy()\n        else:\n            globs = {}\n        if pm:\n            try:\n                execfile(srcfilename, globs, globs)\n            except:\n                print sys.exc_info()[1]\n                pdb.post_mortem(sys.exc_info()[2])\n        else:\n            pdb.run(\"execfile(%r)\" % srcfilename, globs, globs)\n    finally:\n        os.remove(srcfilename)"
    },
    {
        "code": "def _dot_product(self, imgs_to_decode):\n        return np.dot(imgs_to_decode.T, self.feature_images).T"
    },
    {
        "code": "def set_certificate_issuer(\n            self, vault_base_url, issuer_name, provider, credentials=None, organization_details=None, attributes=None, custom_headers=None, raw=False, **operation_config):\n        parameter = models.CertificateIssuerSetParameters(provider=provider, credentials=credentials, organization_details=organization_details, attributes=attributes)\n        url = self.set_certificate_issuer.metadata['url']\n        path_format_arguments = {\n            'vaultBaseUrl': self._serialize.url(\"vault_base_url\", vault_base_url, 'str', skip_quote=True),\n            'issuer-name': self._serialize.url(\"issuer_name\", issuer_name, 'str')\n        }\n        url = self._client.format_url(url, **path_format_arguments)\n        query_parameters = {}\n        query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n        header_parameters = {}\n        header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n        if self.config.generate_client_request_id:\n            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n        if custom_headers:\n            header_parameters.update(custom_headers)\n        if self.config.accept_language is not None:\n            header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n        body_content = self._serialize.body(parameter, 'CertificateIssuerSetParameters')\n        request = self._client.put(url, query_parameters)\n        response = self._client.send(\n            request, header_parameters, body_content, stream=False, **operation_config)\n        if response.status_code not in [200]:\n            raise models.KeyVaultErrorException(self._deserialize, response)\n        deserialized = None\n        if response.status_code == 200:\n            deserialized = self._deserialize('IssuerBundle', response)\n        if raw:\n            client_raw_response = ClientRawResponse(deserialized, response)\n            return client_raw_response\n        return deserialized"
    },
    {
        "code": "def remove_interval(self, time):\n        if self.tier_type != 'IntervalTier':\n            raise Exception('Tiertype must be IntervalTier.')\n        self.intervals = [i for i in self.intervals\n                          if not(i[0] <= time and i[1] >= time)]"
    },
    {
        "code": "def _run_valid(self, epoch, valid_set, dry_run=False, save_path=None):\n        costs = self.valid_step(valid_set)\n        _, J = costs[0]\n        new_best = False\n        if self.best_cost - J > self.best_cost * self.min_improvement:\n            self.best_params = self.copy_params()\n            new_best = True\n            if not dry_run:\n                self.best_cost = J\n                self.best_epoch = epoch\n            self.save_checkpoint(save_path)\n        self.report(dict(costs), type=\"valid\", epoch=0 if dry_run else epoch, new_best=new_best)\n        self.last_run_costs = costs\n        return epoch - self.best_epoch < self.patience"
    },
    {
        "code": "def Bin(self):\n    err = _Bin(self.transit, self.limbdark, self.settings, self.arrays)\n    if err != _ERR_NONE: RaiseError(err)"
    },
    {
        "code": "def get_namespaces(self, prefix=None):\n        params = {\"prefix\": prefix}\n        return self.request(method=\"get\", params=params).json()"
    },
    {
        "code": "def geckoboard_rag_widget(request):\n    params = get_gecko_params(request)\n    print params['uids']\n    max_date = datetime.now()-timedelta(days=params['days_back'])\n    metrics = Metric.objects.filter(uid__in=params['uids'])\n    results = [(metric.latest_count(frequency=params['frequency'], count=not params['cumulative'],\n        cumulative=params['cumulative'], max_date=max_date), metric.title) for metric in metrics]\n    return tuple(results)"
    },
    {
        "code": "def _read_compressed_points_data(self, laszip_vlr, point_format):\n        offset_to_chunk_table = struct.unpack(\"<q\", self.stream.read(8))[0]\n        size_of_point_data = offset_to_chunk_table - self.stream.tell()\n        if offset_to_chunk_table <= 0:\n            logger.warning(\n                \"Strange offset to chunk table: {}, ignoring it..\".format(\n                    offset_to_chunk_table\n                )\n            )\n            size_of_point_data = -1\n        points = record.PackedPointRecord.from_compressed_buffer(\n            self.stream.read(size_of_point_data),\n            point_format,\n            self.header.point_count,\n            laszip_vlr,\n        )\n        return points"
    },
    {
        "code": "def get_system_per_cpu_times():\n    ret = []\n    for cpu_t in _psutil_mswindows.get_system_cpu_times():\n        user, system, idle = cpu_t\n        item = _cputimes_ntuple(user, system, idle)\n        ret.append(item)\n    return ret"
    },
    {
        "code": "def _init_from_bool(self, z, x):\n        if z is None:\n            raise QiskitError(\"z vector must not be None.\")\n        if x is None:\n            raise QiskitError(\"x vector must not be None.\")\n        if len(z) != len(x):\n            raise QiskitError(\"length of z and x vectors must be \"\n                              \"the same. (z: {} vs x: {})\".format(len(z), len(x)))\n        z = _make_np_bool(z)\n        x = _make_np_bool(x)\n        self._z = z\n        self._x = x\n        return self"
    },
    {
        "code": "def _expand_default(self, option):\n    if self.parser is None or not self.default_tag:\n        return option.help\n    optname = option._long_opts[0][2:]\n    try:\n        provider = self.parser.options_manager._all_options[optname]\n    except KeyError:\n        value = None\n    else:\n        optdict = provider.get_option_def(optname)\n        optname = provider.option_attrname(optname, optdict)\n        value = getattr(provider.config, optname, optdict)\n        value = utils._format_option_value(optdict, value)\n    if value is optparse.NO_DEFAULT or not value:\n        value = self.NO_DEFAULT_VALUE\n    return option.help.replace(self.default_tag, str(value))"
    },
    {
        "code": "def map(self, func, value_shape=None, dtype=None):\n        if value_shape is None or dtype is None:\n            try:\n                mapped = func(random.randn(*self.plan).astype(self.dtype))\n            except Exception:\n                first = self._rdd.first()\n                if first:\n                    mapped = func(first[1])\n            if value_shape is None:\n                value_shape = mapped.shape\n            if dtype is None:\n                dtype = mapped.dtype\n        chunked_dims = where(self.plan != self.vshape)[0]\n        unchunked_dims = where(self.plan == self.vshape)[0]\n        if len(value_shape) != len(self.plan):\n            raise NotImplementedError('map on ChunkedArray cannot drop dimensions')\n        if any([value_shape[i] != self.plan[i] for i in chunked_dims]):\n            raise ValueError('map cannot change the sizes of chunked dimensions')\n        def check_and_apply(v):\n            new = func(v)\n            if len(unchunked_dims) > 0:\n                if any([new.shape[i] != value_shape[i] for i in unchunked_dims]):\n                    raise Exception(\"Map operation did not produce values of uniform shape.\")\n            if len(chunked_dims) > 0:\n                if any([v.shape[i] != new.shape[i] for i in chunked_dims]):\n                    raise Exception(\"Map operation changed the size of a chunked dimension\")\n            return new\n        rdd = self._rdd.mapValues(check_and_apply)\n        vshape = [value_shape[i] if i in unchunked_dims else self.vshape[i] for i in range(len(self.vshape))]\n        newshape = r_[self.kshape, vshape].astype(int).tolist()\n        return self._constructor(rdd, shape=tuple(newshape), dtype=dtype,\n                                 plan=asarray(value_shape)).__finalize__(self)"
    },
    {
        "code": "def get_data(self, cache=True, as_text=False, parse_form_data=False):\n        rv = getattr(self, '_cached_data', None)\n        if rv is None:\n            if parse_form_data:\n                self._load_form_data()\n            rv = self.stream.read()\n            if cache:\n                self._cached_data = rv\n        if as_text:\n            rv = rv.decode(self.charset, self.encoding_errors)\n        return rv"
    },
    {
        "code": "def main(mash_output, sample_id):\n    logger.info(\"Reading file : {}\".format(mash_output))\n    read_mash_output = open(mash_output)\n    dic = {}\n    median_list = []\n    filtered_dic = {}\n    logger.info(\"Generating dictionary and list to pre-process the final json\")\n    for line in read_mash_output:\n        tab_split = line.split(\"\\t\")\n        identity = tab_split[0]\n        median_multiplicity = tab_split[2]\n        query_id = tab_split[4]\n        dic[query_id] = [identity, median_multiplicity]\n        median_list.append(float(median_multiplicity))\n    output_json = open(\" \".join(mash_output.split(\".\")[:-1]) + \".json\", \"w\")\n    if len(median_list) > 0:\n        median_cutoff = median(median_list)\n        logger.info(\"Generating final json to dump to a file\")\n        for k, v in dic.items():\n            copy_number = int(float(v[1]) / median_cutoff)\n            if float(v[1]) > median_cutoff:\n                filtered_dic[\"_\".join(k.split(\"_\")[0:3])] = [\n                    round(float(v[0]),2),\n                    copy_number\n                ]\n        logger.info(\n            \"Exported dictionary has {} entries\".format(len(filtered_dic)))\n    else:\n        logger.error(\"No matches were found using mash screen for the queried reads\")\n    output_json.write(json.dumps(filtered_dic))\n    output_json.close()\n    json_dic = {\n        \"tableRow\": [{\n            \"sample\": sample_id,\n            \"data\": [{\n                \"header\": \"Mash Screen\",\n                \"table\": \"plasmids\",\n                \"patlas_mashscreen\": filtered_dic,\n                \"value\": len(filtered_dic)\n            }]\n        }],\n    }\n    with open(\".report.json\", \"w\") as json_report:\n        json_report.write(json.dumps(json_dic, separators=(\",\", \":\")))"
    },
    {
        "code": "def add_import(\n        self, sym: sym.Symbol, module: types.ModuleType, *aliases: sym.Symbol\n    ) -> None:\n        self._imports.swap(lambda m: m.assoc(sym, module))\n        if aliases:\n            self._import_aliases.swap(\n                lambda m: m.assoc(\n                    *itertools.chain.from_iterable([(alias, sym) for alias in aliases])\n                )\n            )"
    },
    {
        "code": "def delete_report(self, report):\n        url = ACCOUNTS_API.format(report.account_id) + \"/reports/{}/{}\".format(\n            report.type, report.report_id)\n        response = self._delete_resource(url)\n        return True"
    },
    {
        "code": "def delete(self, blocksize=100):\n        from .columns import MODELS_REFERENCED\n        if not self._model._no_fk or self._model._namespace in MODELS_REFERENCED:\n            raise QueryError(\"Can't delete entities of models with foreign key relationships\")\n        de = []\n        i = 0\n        for result in self.iter_result(pagesize=blocksize):\n            de.append(result)\n            i += 1\n            if i >= blocksize:\n                session.delete(de)\n                del de[:]\n                i = 0\n        if de:\n            session.delete(de)"
    },
    {
        "code": "def _ep_need_close(self):\n        LOG.debug(\"Session %s close requested - closing...\",\n                  self._name)\n        links = self._links.copy()\n        for link in links:\n            link._session_closed()"
    },
    {
        "code": "def users(store):\n    user_objs = list(store.users())\n    total_events = store.user_events().count()\n    for user_obj in user_objs:\n        if user_obj.get('institutes'):\n            user_obj['institutes'] = [store.institute(inst_id) for inst_id in user_obj.get('institutes')]\n        else:\n            user_obj['institutes'] = []\n        user_obj['events'] = store.user_events(user_obj).count()\n        user_obj['events_rank'] = event_rank(user_obj['events'])\n    return dict(\n        users=sorted(user_objs, key=lambda user: -user['events']),\n        total_events=total_events,\n    )"
    },
    {
        "code": "def linear_connection(plist, lane):\n    logger.debug(\n        \"Establishing linear connection with processes: {}\".format(plist))\n    res = []\n    previous = None\n    for p in plist:\n        if not previous:\n            previous = p\n            continue\n        res.append({\n            \"input\": {\n                \"process\": previous,\n                \"lane\": lane\n            },\n            \"output\": {\n                \"process\": p,\n                \"lane\": lane\n            }\n        })\n        previous = p\n    return res"
    },
    {
        "code": "def run_migrations_online():\n    connectable = settings.engine\n    with connectable.connect() as connection:\n        context.configure(\n            connection=connection,\n            transaction_per_migration=True,\n            target_metadata=target_metadata,\n            compare_type=COMPARE_TYPE,\n        )\n        with context.begin_transaction():\n            context.run_migrations()"
    },
    {
        "code": "def map_generic(self, func):\n        def process_record(val):\n            newval = empty(1, dtype=\"object\")\n            newval[0]  = func(val)\n            return newval\n        rdd = self._rdd.mapValues(process_record)\n        nchunks = self.getnumber(self.plan, self.vshape)\n        newshape = tuple([int(s) for s in r_[self.kshape, nchunks]])\n        newsplit = len(self.shape)\n        return BoltArraySpark(rdd, shape=newshape, split=newsplit, ordered=self._ordered, dtype=\"object\")"
    },
    {
        "code": "def get_conn(self):\n        if not self._conn:\n            http_authorized = self._authorize()\n            self._conn = build('compute', self.api_version,\n                               http=http_authorized, cache_discovery=False)\n        return self._conn"
    },
    {
        "code": "def parse_args(argv):\n    global g_new_messages_to_exclude\n    global g_old_messages_to_remove\n    global g_load_java_message_filename\n    global g_save_java_message_filename\n    global g_print_java_messages\n    if len(argv) < 2:\n        usage()\n    i = 1\n    while (i < len(argv)):\n        s = argv[i]\n        if (s == \"--inputfileadd\"):\n            i += 1\n            if (i > len(argv)):\n                usage()\n            g_new_messages_to_exclude = argv[i]\n        elif (s == \"--inputfilerm\"):\n            i += 1\n            if (i > len(argv)):\n                usage()\n            g_old_messages_to_remove = argv[i]\n        elif (s == \"--loadjavamessage\"):\n            i += 1\n            if i > len(argv):\n                usage()\n            g_load_java_message_filename = argv[i]\n        elif (s == \"--savejavamessage\"):\n            i += 1\n            if (i > len(argv)):\n                usage()\n            g_save_java_message_filename = argv[i]\n        elif (s == '--printjavamessage'):\n            i += 1\n            g_print_java_messages = True\n            g_load_java_message_filename = argv[i]\n        elif (s == '--help'):\n            usage()\n        else:\n            unknown_arg(s)\n        i += 1"
    },
    {
        "code": "def expand_files(self, modules):\n        result, errors = utils.expand_modules(\n            modules, self.config.black_list, self.config.black_list_re\n        )\n        for error in errors:\n            message = modname = error[\"mod\"]\n            key = error[\"key\"]\n            self.set_current_module(modname)\n            if key == \"fatal\":\n                message = str(error[\"ex\"]).replace(os.getcwd() + os.sep, \"\")\n            self.add_message(key, args=message)\n        return result"
    },
    {
        "code": "def _m(self):\n        assert not hasattr(self, \"_interfaces\") or not self._interfaces, \\\n            \"Too late to change direction of interface\"\n        self._direction = DIRECTION.asIntfDirection(DIRECTION.opposite(self._masterDir))\n        return self"
    },
    {
        "code": "def __nn_filter_helper(R_data, R_indices, R_ptr, S, aggregate):\n    s_out = np.empty_like(S)\n    for i in range(len(R_ptr)-1):\n        targets = R_indices[R_ptr[i]:R_ptr[i+1]]\n        if not len(targets):\n            s_out[i] = S[i]\n            continue\n        neighbors = np.take(S, targets, axis=0)\n        if aggregate is np.average:\n            weights = R_data[R_ptr[i]:R_ptr[i+1]]\n            s_out[i] = aggregate(neighbors, axis=0, weights=weights)\n        else:\n            s_out[i] = aggregate(neighbors, axis=0)\n    return s_out"
    },
    {
        "code": "def fit(self, Z, **fit_params):\n        Zt, fit_params = self._pre_transform(Z, **fit_params)\n        self.steps[-1][-1].fit(Zt, **fit_params)\n        Zt.unpersist()\n        return self"
    },
    {
        "code": "def _make_content_item(node, mime_type=None, alternate_data=None):\n    raw = node.data\n    if getattr(node, 'encoding', None) == 'zlib':\n        try:\n            raw = zlib.decompress(node.data)\n        except Exception, exc:\n            if alternate_data is not None:\n                try:\n                    raw = zlib.decompress(alternate_data)\n                except Exception:\n                    raise exc\n                else:\n                    raise\n    if mime_type is None:\n        mime_type = node.mime_type\n    raw = raw.decode('utf8').encode('utf8')\n    return streamcorpus.ContentItem(raw=raw, media_type=mime_type)"
    },
    {
        "code": "def simUnit(self, synthesisedUnit: Unit, until: float, extraProcesses=[]):\n        beforeSim = self.config.beforeSim\n        if beforeSim is not None:\n            beforeSim(self, synthesisedUnit)\n        add_proc = self.add_process\n        for p in extraProcesses:\n            add_proc(p(self))\n        self._initUnitSignals(synthesisedUnit)\n        self.run(until)"
    },
    {
        "code": "def parse(self, hcl, canonicalize=False):\n        return self.request(\"parse\", json={\"JobHCL\": hcl, \"Canonicalize\": canonicalize}, method=\"post\", allow_redirects=True).json()"
    },
    {
        "code": "def has_no_unchecked_field(self, locator, **kwargs):\n        kwargs[\"checked\"] = False\n        return self.has_no_selector(\"field\", locator, **kwargs)"
    },
    {
        "code": "def reconnect(self):\n        self.log.debug(\"reconnect(): Initialzion reconnect sequence..\")\n        self.connected.clear()\n        self.reconnect_required.set()\n        if self.socket:\n            self.socket.close()"
    },
    {
        "code": "def lowpass_filter(data, cutoff, fs, order=5):\n    nyq = 0.5 * fs\n    normal_cutoff = cutoff / nyq\n    b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n    y = signal.lfilter(b, a, data)\n    return y"
    },
    {
        "code": "def _add(self, to_add):\n        if PyFunceble.CONFIGURATION[\"mining\"]:\n            if PyFunceble.INTERN[\"file_to_test\"] not in PyFunceble.INTERN[\"mined\"]:\n                PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]] = {}\n            for element in to_add:\n                if (\n                    element\n                    in PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]]\n                ):\n                    PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n                        element\n                    ].extend(to_add[element])\n                else:\n                    PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n                        element\n                    ] = to_add[element]\n                PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n                    element\n                ] = List(\n                    PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n                        element\n                    ]\n                ).format()\n            self._backup()"
    },
    {
        "code": "def square(duration: int, amp: complex, period: float = None,\n           phase: float = 0, name: str = None) -> SamplePulse:\n    if period is None:\n        period = duration\n    return _sampled_square_pulse(duration, amp, period, phase=phase, name=name)"
    },
    {
        "code": "def size(self, train=False, valid=False, xval=False):\n        tm = ModelBase._get_metrics(self, train, valid, xval)\n        m = {}\n        for k, v in tm.items():\n            m[k] = None if v is None else [v[2] for v in v._metric_json[\"centroid_stats\"].cell_values]\n        return list(m.values())[0] if len(m) == 1 else m"
    },
    {
        "code": "def find_files(filenames, recursive, exclude):\n    while filenames:\n        name = filenames.pop(0)\n        if recursive and os.path.isdir(name):\n            for root, directories, children in os.walk(name):\n                filenames += [os.path.join(root, f) for f in children\n                              if match_file(os.path.join(root, f),\n                                            exclude)]\n                directories[:] = [d for d in directories\n                                  if match_file(os.path.join(root, d),\n                                                exclude)]\n        else:\n            if not is_exclude_file(name, exclude):\n                yield name"
    },
    {
        "code": "def is_literal_or_name(value):\n    try:\n        ast.literal_eval(value)\n        return True\n    except (SyntaxError, ValueError):\n        pass\n    if value.strip() in ['dict()', 'list()', 'set()']:\n        return True\n    return re.match(r'^\\w+\\s*$', value)"
    },
    {
        "code": "def complete_restore(\n            self, location_name, operation_id, last_backup_name, custom_headers=None, raw=False, polling=True, **operation_config):\n        raw_result = self._complete_restore_initial(\n            location_name=location_name,\n            operation_id=operation_id,\n            last_backup_name=last_backup_name,\n            custom_headers=custom_headers,\n            raw=True,\n            **operation_config\n        )\n        def get_long_running_output(response):\n            if raw:\n                client_raw_response = ClientRawResponse(None, response)\n                return client_raw_response\n        lro_delay = operation_config.get(\n            'long_running_operation_timeout',\n            self.config.long_running_operation_timeout)\n        if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)\n        elif polling is False: polling_method = NoPolling()\n        else: polling_method = polling\n        return LROPoller(self._client, raw_result, get_long_running_output, polling_method)"
    },
    {
        "code": "def post(self, headers={}, body=\"\"):\n        code, message = self.command(\"POST\")\n        if code != 340:\n            raise NNTPReplyError(code, message)\n        hdrs = utils.unparse_headers(headers)\n        self.socket.sendall(hdrs)\n        if isinstance(body, basestring):\n            body = cStringIO.StringIO(body)\n        illegal = False\n        for line in body:\n            if line.startswith(\".\"):\n                line = \".\" + line\n            if line.endswith(\"\\r\\n\"):\n                line = line[:-2]\n            elif line.endswith(\"\\n\"):\n                line = line[:-1]\n            if any(c in line for c in \"\\0\\r\"):\n                illegal = True\n                break\n            self.socket.sendall(line + \"\\r\\n\")\n        self.socket.sendall(\".\\r\\n\")\n        code, message = self.status()\n        if illegal:\n            raise NNTPDataError(\"Illegal characters found\")\n        if code != 240:\n            raise NNTPReplyError(code, message)\n        message_id = message.split(None, 1)[0]\n        if message_id.startswith(\"<\") and message_id.endswith(\">\"):\n            return message_id\n        return True"
    },
    {
        "code": "def has_context_loop(state, incorrect_msg, exact_names):\n    return _test(\n        state,\n        incorrect_msg or MSG_INCORRECT_LOOP,\n        exact_names,\n        tv_name=\"_target_vars\",\n        highlight_name=\"target\",\n    )"
    },
    {
        "code": "def imcrop(img, bboxes, scale=1.0, pad_fill=None):\n    chn = 1 if img.ndim == 2 else img.shape[2]\n    if pad_fill is not None:\n        if isinstance(pad_fill, (int, float)):\n            pad_fill = [pad_fill for _ in range(chn)]\n        assert len(pad_fill) == chn\n    _bboxes = bboxes[None, ...] if bboxes.ndim == 1 else bboxes\n    scaled_bboxes = bbox_scaling(_bboxes, scale).astype(np.int32)\n    clipped_bbox = bbox_clip(scaled_bboxes, img.shape)\n    patches = []\n    for i in range(clipped_bbox.shape[0]):\n        x1, y1, x2, y2 = tuple(clipped_bbox[i, :])\n        if pad_fill is None:\n            patch = img[y1:y2 + 1, x1:x2 + 1, ...]\n        else:\n            _x1, _y1, _x2, _y2 = tuple(scaled_bboxes[i, :])\n            if chn == 2:\n                patch_shape = (_y2 - _y1 + 1, _x2 - _x1 + 1)\n            else:\n                patch_shape = (_y2 - _y1 + 1, _x2 - _x1 + 1, chn)\n            patch = np.array(\n                pad_fill, dtype=img.dtype) * np.ones(\n                    patch_shape, dtype=img.dtype)\n            x_start = 0 if _x1 >= 0 else -_x1\n            y_start = 0 if _y1 >= 0 else -_y1\n            w = x2 - x1 + 1\n            h = y2 - y1 + 1\n            patch[y_start:y_start + h, x_start:x_start +\n                  w, ...] = img[y1:y1 + h, x1:x1 + w, ...]\n        patches.append(patch)\n    if bboxes.ndim == 1:\n        return patches[0]\n    else:\n        return patches"
    },
    {
        "code": "def validate(self, obj, value):\n        try:\n            if issubclass(value, self.klass):\n                return value\n        except:\n            if (value is None) and (self._allow_none):\n                return value\n        self.error(obj, value)"
    },
    {
        "code": "def plot(\n            self, data, bbox=None, plot_type='scatter',\n            fig_kwargs=None, bmap_kwargs=None, plot_kwargs=None,\n            cbar_kwargs=None):\n        from mpl_toolkits.basemap import Basemap\n        fig_kwargs = fig_kwargs or {}\n        bmap_kwargs = bmap_kwargs or {}\n        plot_kwargs = plot_kwargs or {}\n        cbar_kwargs = cbar_kwargs or {}\n        if not bbox:\n            bbox = (\n                self.nodes_df.y.min(),\n                self.nodes_df.x.min(),\n                self.nodes_df.y.max(),\n                self.nodes_df.x.max())\n        fig, ax = plt.subplots(**fig_kwargs)\n        bmap = Basemap(\n            bbox[1], bbox[0], bbox[3], bbox[2], ax=ax, **bmap_kwargs)\n        bmap.drawcoastlines()\n        bmap.drawmapboundary()\n        x, y = bmap(self.nodes_df.x.values, self.nodes_df.y.values)\n        if plot_type == 'scatter':\n            plot = bmap.scatter(\n                x, y, c=data.values, **plot_kwargs)\n        elif plot_type == 'hexbin':\n            plot = bmap.hexbin(\n                x, y, C=data.values, **plot_kwargs)\n        bmap.colorbar(plot, **cbar_kwargs)\n        return bmap, fig, ax"
    },
    {
        "code": "def update_configuration(cfgfile=None):\n    configobj.DEFAULT_INTERPOLATION = 'template'\n    cfgfile = configuration_file(cfgfile)\n    cfg = configobj.ConfigObj(cfgfile, configspec=cfgspec, encoding='utf-8')\n    validator = Validator()\n    val = cfg.validate(validator)\n    if val is not True:\n        raise ValueError('Invalid configuration: %s' % val)\n    if len(cfg['capture']['files']) != len(cfg['capture']['flavors']):\n        raise ValueError('List of files and flavors do not match')\n    globals()['__config'] = cfg\n    logger_init()\n    if cfg['server'].get('url', '').endswith('/'):\n        logger.warning('Base URL ends with /. This is most likely a '\n                       'configuration error. The URL should contain nothing '\n                       'of the service paths.')\n    logger.info('Configuration loaded from %s' % cfgfile)\n    check()\n    return cfg"
    },
    {
        "code": "def times_csv(path, times, annotations=None, delimiter=',', fmt='%0.3f'):\n    r\n    if annotations is not None and len(annotations) != len(times):\n        raise ParameterError('len(annotations) != len(times)')\n    with open(path, 'w') as output_file:\n        writer = csv.writer(output_file, delimiter=delimiter)\n        if annotations is None:\n            for t in times:\n                writer.writerow([fmt % t])\n        else:\n            for t, lab in zip(times, annotations):\n                writer.writerow([(fmt % t), lab])"
    },
    {
        "code": "def add_subgraph(self, info):\n        if not info.initialized:\n            return\n        graph = self._request_graph(info.ui.control)\n        if graph is not None:\n            subgraph = Subgraph()\n            retval = subgraph.edit_traits(parent = info.ui.control,\n                                          kind   = \"livemodal\")\n            if retval.result:\n                graph.subgraphs.append(subgraph)"
    },
    {
        "code": "def _onDeviceStatus(self, client, userdata, pahoMessage):\n        try:\n            status = Status(pahoMessage)\n            self.logger.debug(\"Received %s action from %s\" % (status.action, status.clientId))\n            if self.deviceStatusCallback:\n                self.deviceStatusCallback(status)\n        except InvalidEventException as e:\n            self.logger.critical(str(e))"
    },
    {
        "code": "def get_input(prompt, default=None, exit_msg='bye!'):\n    try:\n        response = six.moves.input(prompt)\n    except (KeyboardInterrupt, EOFError):\n        print()\n        print(exit_msg)\n        exit()\n    try:\n        return int(response)\n    except ValueError:\n        if response.strip() == \"\" and default is not None:\n            return default\n        else:\n            return response"
    },
    {
        "code": "def encode(self):\n        header    = bytearray(1)\n        varHeader = encode16Int(self.msgId)\n        header[0] = 0xB0 \n        header.extend(encodeLength(len(varHeader)))\n        header.extend(varHeader)\n        self.encoded = header\n        return str(header) if PY2 else bytes(header)"
    },
    {
        "code": "def set_piece_at(self, square, piece, from_hand=False, into_hand=False):\n        if from_hand:\n            self.remove_piece_from_hand(piece.piece_type, self.turn)\n        self.remove_piece_at(square, into_hand)\n        self.pieces[square] = piece.piece_type\n        mask = BB_SQUARES[square]\n        piece_type = piece.piece_type\n        self.piece_bb[piece_type] |= mask\n        if piece_type == KING:\n            self.king_squares[piece.color] = square\n        self.occupied.ixor(mask, piece.color, square)\n        if piece.color == BLACK:\n            piece_index = (piece.piece_type - 1) * 2\n        else:\n            piece_index = (piece.piece_type - 1) * 2 + 1\n        self.incremental_zobrist_hash ^= DEFAULT_RANDOM_ARRAY[81 * piece_index + 9 * rank_index(square) + file_index(square)]"
    },
    {
        "code": "def _check_relative_import(\n        self, modnode, importnode, importedmodnode, importedasname\n    ):\n        if not self.linter.is_message_enabled(\"relative-import\"):\n            return None\n        if importedmodnode.file is None:\n            return False\n        if modnode is importedmodnode:\n            return False\n        if modnode.absolute_import_activated() or getattr(importnode, \"level\", None):\n            return False\n        if importedmodnode.name != importedasname:\n            self.add_message(\n                \"relative-import\",\n                args=(importedasname, importedmodnode.name),\n                node=importnode,\n            )\n            return None\n        return None"
    },
    {
        "code": "def sold_out_and_unregistered(context):\n    user = user_for_context(context)\n    if hasattr(user, \"attendee\") and user.attendee.completed_registration:\n        return None\n    ticket_category = settings.TICKET_PRODUCT_CATEGORY\n    categories = available_categories(context)\n    return ticket_category not in [cat.id for cat in categories]"
    },
    {
        "code": "def is_token_from_emulator(auth_header: str) -> bool:\n        if not auth_header:\n            return False\n        parts = auth_header.split(' ')\n        if len(parts) != 2:\n            return False\n        auth_scheme = parts[0]\n        bearer_token = parts[1]\n        if auth_scheme != 'Bearer':\n            return False\n        token = jwt.decode(bearer_token, verify=False)\n        if not token:\n            return False\n        issuer = token['iss']\n        if not issuer:\n            return False\n        issuer_list = EmulatorValidation.TO_BOT_FROM_EMULATOR_TOKEN_VALIDATION_PARAMETERS.issuer\n        if issuer_list and not issuer in issuer_list:\n            return False\n        return True"
    },
    {
        "code": "def render_template(template_file, dst_file, **kwargs):\n    with open(template_file) as f:\n        template_text = f.read()\n    dst_text = template_text\n    for key, value in kwargs.iteritems():\n        dst_text = dst_text .replace(\"{{\" + key + \"}}\", value)\n    with open(dst_file, \"wt\") as f:\n        f.write(dst_text)"
    },
    {
        "code": "def is_subdomain(self, domain=None):\n        if domain:\n            to_test = domain\n        elif self.element:\n            to_test = self.element\n        else:\n            to_test = PyFunceble.INTERN[\"to_test\"]\n        return self.is_domain_valid(to_test, subdomain_check=True)"
    },
    {
        "code": "def make_logging_handlers_and_tools(self, multiproc=False):\n        log_stdout = self.log_stdout\n        if sys.stdout is self._stdout_to_logger:\n            log_stdout = False\n        if self.log_config:\n            if multiproc:\n                proc_log_config = self._mp_config\n            else:\n                proc_log_config = self._sp_config\n            if proc_log_config:\n                if isinstance(proc_log_config, dict):\n                    new_dict = self._handle_dict_config(proc_log_config)\n                    dictConfig(new_dict)\n                else:\n                    parser = self._handle_config_parsing(proc_log_config)\n                    memory_file = self._parser_to_string_io(parser)\n                    fileConfig(memory_file, disable_existing_loggers=False)\n        if log_stdout:\n            std_name, std_level = self.log_stdout\n            stdout = StdoutToLogger(std_name, log_level=std_level)\n            stdout.start()\n            self._tools.append(stdout)"
    },
    {
        "code": "def _get_index_urls_locations(self, project_name):\n        def mkurl_pypi_url(url):\n            loc = posixpath.join(url, project_url_name)\n            if not loc.endswith('/'):\n                loc = loc + '/'\n            return loc\n        project_url_name = urllib_parse.quote(project_name.lower())\n        if self.index_urls:\n            main_index_url = Link(\n                mkurl_pypi_url(self.index_urls[0]),\n                trusted=True,\n            )\n            page = self._get_page(main_index_url)\n            if page is None and PyPI.netloc not in str(main_index_url):\n                warnings.warn(\n                    \"Failed to find %r at %s. It is suggested to upgrade \"\n                    \"your index to support normalized names as the name in \"\n                    \"/simple/{name}.\" % (project_name, main_index_url),\n                    RemovedInPip8Warning,\n                )\n                project_url_name = self._find_url_name(\n                    Link(self.index_urls[0], trusted=True),\n                    project_url_name,\n                ) or project_url_name\n        if project_url_name is not None:\n            return [mkurl_pypi_url(url) for url in self.index_urls]\n        return []"
    },
    {
        "code": "def _setup_logging(self, log_level: str):\n        level = getattr(logging, log_level)\n        names = (\n            'aiohttp.access', 'aiohttp.internal', 'aiohttp.server',\n            'aiohttp.web', self.name)\n        for name in names:\n            setup_logger(name=name, stream=sys.stderr, level=level)"
    },
    {
        "code": "def parse(self, selector):\n        log.debug(self.obj)\n        tokens = lex(selector)\n        if self.peek(tokens, 'operator') == '*':\n            self.match(tokens, 'operator')\n            results = list(object_iter(self.obj))\n        else:\n            results = self.selector_production(tokens)\n        results = [node.value for node in results]\n        if len(results) == 1:\n            return results[0]\n        elif not len(results):\n            return None\n        return results"
    },
    {
        "code": "def bandpass_filter(data, low, high, fs, order=5):\n    nyq = 0.5 * fs\n    low = low / nyq\n    high = high / nyq\n    b, a = signal.butter(order, [low, high], btype='band')\n    y = signal.lfilter(b, a, data)\n    return y"
    },
    {
        "code": "def build_schema(m, c_c):\n    schema = ET.Element('xs:schema')\n    schema.set('xmlns:xs', 'http://www.w3.org/2001/XMLSchema')\n    global_filter = lambda selected: ooaofooa.is_global(selected)\n    for s_dt in m.select_many('S_DT', global_filter):\n        datatype = build_type(s_dt)\n        if datatype is not None:\n            schema.append(datatype)\n    scope_filter = lambda selected: ooaofooa.is_contained_in(selected, c_c)\n    for s_dt in m.select_many('S_DT', scope_filter):\n        datatype = build_type(s_dt)\n        if datatype is not None:\n            schema.append(datatype)\n    component = build_component(m, c_c)\n    schema.append(component)\n    return schema"
    },
    {
        "code": "def execute(option):\n    namelist_option = []\n    makefile_option = []\n    flags = \"\"\n    for entry in option:\n        key = entry.keys()[0]\n        if key == \"Problem Size\":\n            namelist_option.append({\"SIZE\": entry[key]})\n        elif key == \"F90\":\n            makefile_option.append(entry)\n        else:\n            flags += entry[key] + \" \"\n    makefile_option.append({\"F90FLAGS\": flags})\n    namelist = create_input(namelist_option, \"namelist\",\n                            template_location=\"templates\")\n    makefile_include = create_input(makefile_option, \"Makefile.include\",\n                                    template_location=\"templates\")\n    benchmark_base = \"shallow\"\n    location = benchmark_base + \"/original/namelist\"\n    my_file = open(location, 'w')\n    my_file.write(namelist)\n    my_file.flush()\n    location = benchmark_base + \"/common/Makefile.include\"\n    my_file = open(location, 'w')\n    my_file.write(makefile_include)\n    my_file.flush()\n    base_path = benchmark_base + \"/original\"\n    import subprocess\n    make_process = subprocess.Popen([\"make\", \"clean\"], cwd=base_path,\n                                    stderr=subprocess.PIPE,\n                                    stdout=subprocess.PIPE)\n    if make_process.wait() != 0:\n        return False, []\n    make_process = subprocess.Popen([\"make\"], cwd=base_path,\n                                    stderr=subprocess.PIPE,\n                                    stdout=subprocess.PIPE)\n    if make_process.wait() != 0:\n        return False, []\n    make_process = subprocess.Popen([\"./shallow_base\"], cwd=base_path,\n                                    stderr=subprocess.PIPE,\n                                    stdout=subprocess.PIPE)\n    if make_process.wait() != 0:\n        return False, []\n    stdout = make_process.stdout.read()\n    for line in stdout.split(\"\\n\"):\n        if \"Time-stepping\" in line:\n            total_time = line.split()[2]\n    return True, total_time"
    },
    {
        "code": "def img_from_vgg(x):\n    x = x.transpose((1, 2, 0))\n    x[:, :, 0] += 103.939\n    x[:, :, 1] += 116.779\n    x[:, :, 2] += 123.68\n    x = x[:,:,::-1]\n    return x"
    },
    {
        "code": "def remove_unique_identifiers(identifiers_to_tags, pipeline_links):\n    for index, val in enumerate(pipeline_links):\n        if val[\"input\"][\"process\"] != \"__init__\":\n            val[\"input\"][\"process\"] = identifiers_to_tags[\n                val[\"input\"][\"process\"]]\n        if val[\"output\"][\"process\"] != \"__init__\":\n            val[\"output\"][\"process\"] = identifiers_to_tags[\n                val[\"output\"][\"process\"]]\n    return pipeline_links"
    },
    {
        "code": "def fetch_items(self, category, **kwargs):\n        from_date = kwargs['from_date']\n        if self.client.version[0] == 2 and self.client.version[1] == 8:\n            fetcher = self._fetch_gerrit28(from_date)\n        else:\n            fetcher = self._fetch_gerrit(from_date)\n        for review in fetcher:\n            yield review"
    },
    {
        "code": "def _imported_module(self, node, mod_path, relative):\n        module = node.root()\n        context_name = module.name\n        if relative:\n            mod_path = \"%s.%s\" % (\".\".join(context_name.split(\".\")[:-1]), mod_path)\n        if self.compute_module(context_name, mod_path):\n            if not hasattr(module, \"depends\"):\n                module.depends = []\n            mod_paths = module.depends\n            if mod_path not in mod_paths:\n                mod_paths.append(mod_path)"
    },
    {
        "code": "def _get_existing_instance(self, query, value):\n        if self.columns:\n            result = query.filter_by(\n                **{prop.key: value.get(prop.key) for prop in self.related_keys}\n            ).one()\n        else:\n            result = query.get([value.get(prop.key) for prop in self.related_keys])\n            if result is None:\n                raise NoResultFound\n        return result"
    },
    {
        "code": "def deprecated(*args):\n    def wrap(func):\n        def wrapped_func(*args, **kwargs):\n            warnings.warn(msg, category=DeprecationWarning)\n            return func(*args, **kwargs)\n        return wrapped_func\n    if len(args) == 1 and callable(args[0]):\n        msg = \"Function '%s' will be deprecated in future versions of \" \\\n            \"Neurosynth.\" % args[0].__name__\n        return wrap(args[0])\n    else:\n        msg = args[0]\n        return wrap"
    },
    {
        "code": "def _get_required_args(fn):\n  argspec = tf_inspect.getfullargspec(fn)\n  args = argspec.args\n  if tf_inspect.isclass(fn):\n    args = args[1:]\n  if argspec.defaults:\n    args = args[:-len(argspec.defaults)]\n  return tuple(args)"
    },
    {
        "code": "def compute_lst(self):\n        if self.header[b'telescope_id'] == 6:\n            self.coords = gbt_coords\n        elif self.header[b'telescope_id'] == 4:\n            self.coords = parkes_coords\n        else:\n            raise RuntimeError(\"Currently only Parkes and GBT supported\")\n        if HAS_SLALIB:\n            dut1 = 0.0\n            mjd = self.header[b'tstart']\n            tellong = np.deg2rad(self.coords[1])\n            last = s.sla_gmst(mjd) - tellong + s.sla_eqeqx(mjd) + dut1\n            if last < 0.0 : last = last + 2.0*np.pi\n            return last\n        else:\n            raise RuntimeError(\"This method requires pySLALIB\")"
    },
    {
        "code": "def register_metric(metric_name: str) -> Callable[..., Any]:\n    def decorate(fn):\n        fn_name = fn.__module__ + ':' + fn.__name__\n        if metric_name in _REGISTRY and _REGISTRY[metric_name] != fn_name:\n            log.warning('\"{}\" is already registered as a metric name, the old function will be ignored'\n                        .format(metric_name))\n        _REGISTRY[metric_name] = fn_name\n        return fn\n    return decorate"
    },
    {
        "code": "def _check_type(var, vtype):\n    if vtype is None:\n        return var is None\n    if isinstance(vtype, _primitive_type):\n        return var == vtype\n    if vtype is str:\n        return isinstance(var, _str_type)\n    if vtype is int:\n        return isinstance(var, _int_type)\n    if vtype is numeric:\n        return isinstance(var, _num_type)\n    if isinstance(vtype, MagicType):\n        return vtype.check(var)\n    if isinstance(vtype, type):\n        return isinstance(var, vtype)\n    if isinstance(vtype, list):\n        elem_type = U(*vtype)\n        return isinstance(var, list) and all(_check_type(item, elem_type) for item in var)\n    if isinstance(vtype, set):\n        elem_type = U(*vtype)\n        return isinstance(var, set) and all(_check_type(item, elem_type) for item in var)\n    if isinstance(vtype, tuple):\n        return (isinstance(var, tuple) and len(vtype) == len(var) and\n                all(_check_type(var[i], vtype[i]) for i in range(len(vtype))))\n    if isinstance(vtype, dict):\n        ttkv = U(*viewitems(vtype))\n        return isinstance(var, dict) and all(_check_type(kv, ttkv) for kv in viewitems(var))\n    if isinstance(vtype, (FunctionType, BuiltinFunctionType)):\n        return vtype(var)\n    raise RuntimeError(\"Ivalid type %r in _check_type()\" % vtype)"
    },
    {
        "code": "def _basilisp_bytecode(\n    mtime: int, source_size: int, code: List[types.CodeType]\n) -> bytes:\n    data = bytearray(MAGIC_NUMBER)\n    data.extend(_w_long(mtime))\n    data.extend(_w_long(source_size))\n    data.extend(marshal.dumps(code))\n    return data"
    },
    {
        "code": "def select_name_pattern(source, pat):\n    return filter(lambda x: pat.match(x.xml_name) is not None, select_elements(source))"
    },
    {
        "code": "def get_overrides_filename(variable):\n    filename = os.environ.get(variable)\n    if filename is None:\n        msg = 'Please set the {} environment variable.'.format(variable)\n        raise EnvironmentError(msg)\n    return filename"
    },
    {
        "code": "def get_order(self, order_id):\n        resp = self.get('/orders/{}'.format(order_id))\n        return Order(resp)"
    },
    {
        "code": "def networkdays(from_date, to_date, locale='en-US'):\n    holidays = locales[locale]\n    return workdays.networkdays(from_date, to_date, holidays)"
    },
    {
        "code": "def start_proxy(self):\n        self._download_sql_proxy_if_needed()\n        if self.sql_proxy_process:\n            raise AirflowException(\"The sql proxy is already running: {}\".format(\n                self.sql_proxy_process))\n        else:\n            command_to_run = [self.sql_proxy_path]\n            command_to_run.extend(self.command_line_parameters)\n            try:\n                self.log.info(\"Creating directory %s\",\n                              self.cloud_sql_proxy_socket_directory)\n                os.makedirs(self.cloud_sql_proxy_socket_directory)\n            except OSError:\n                pass\n            command_to_run.extend(self._get_credential_parameters())\n            self.log.info(\"Running the command: `%s`\", \" \".join(command_to_run))\n            self.sql_proxy_process = Popen(command_to_run,\n                                           stdin=PIPE, stdout=PIPE, stderr=PIPE)\n            self.log.info(\"The pid of cloud_sql_proxy: %s\", self.sql_proxy_process.pid)\n            while True:\n                line = self.sql_proxy_process.stderr.readline().decode('utf-8')\n                return_code = self.sql_proxy_process.poll()\n                if line == '' and return_code is not None:\n                    self.sql_proxy_process = None\n                    raise AirflowException(\n                        \"The cloud_sql_proxy finished early with return code {}!\".format(\n                            return_code))\n                if line != '':\n                    self.log.info(line)\n                if \"googleapi: Error\" in line or \"invalid instance name:\" in line:\n                    self.stop_proxy()\n                    raise AirflowException(\n                        \"Error when starting the cloud_sql_proxy {}!\".format(\n                            line))\n                if \"Ready for new connections\" in line:\n                    return"
    },
    {
        "code": "def init_role(self, role_name, role_vms, role_perms):\n        pvms = self.get_session.query(sqla_models.PermissionView).all()\n        pvms = [p for p in pvms if p.permission and p.view_menu]\n        role = self.find_role(role_name)\n        if not role:\n            role = self.add_role(role_name)\n        if len(role.permissions) == 0:\n            self.log.info('Initializing permissions for role:%s in the database.', role_name)\n            role_pvms = set()\n            for pvm in pvms:\n                if pvm.view_menu.name in role_vms and pvm.permission.name in role_perms:\n                    role_pvms.add(pvm)\n            role.permissions = list(role_pvms)\n            self.get_session.merge(role)\n            self.get_session.commit()\n        else:\n            self.log.debug('Existing permissions for the role:%s '\n                           'within the database will persist.', role_name)"
    },
    {
        "code": "def glm(interactive=True, echo=True, testing=False):\n    def demo_body(go):\n        go()\n        h2o.init()\n        go()\n        prostate = h2o.load_dataset(\"prostate\")\n        go()\n        prostate.describe()\n        go()\n        train, test = prostate.split_frame(ratios=[0.70])\n        go()\n        train[\"CAPSULE\"] = train[\"CAPSULE\"].asfactor()\n        test[\"CAPSULE\"] = test[\"CAPSULE\"].asfactor()\n        go()\n        from h2o.estimators import H2OGeneralizedLinearEstimator\n        prostate_glm = H2OGeneralizedLinearEstimator(family=\"binomial\", alpha=[0.5])\n        prostate_glm.train(x=[\"AGE\", \"RACE\", \"PSA\", \"VOL\", \"GLEASON\"],\n                           y=\"CAPSULE\", training_frame=train)\n        go()\n        prostate_glm.show()\n        go()\n        predictions = prostate_glm.predict(test)\n        predictions.show()\n        go()\n        performance = prostate_glm.model_performance(test)\n        performance.show()\n    _run_demo(demo_body, interactive, echo, testing)"
    },
    {
        "code": "def dsync_handler(self, args):\n    self.opt.recursive = True\n    self.opt.sync_check = True\n    self.opt.force = True\n    self.validate('cmd|s3,local|s3,local', args)\n    source = args[1]\n    target = args[2]\n    self.s3handler().dsync_files(source, target)"
    },
    {
        "code": "def mkstemp(self, suffix, prefix, directory=None):\n        if not directory:\n            directory = self.artifacts_dir\n        fd, fname = tempfile.mkstemp(suffix, prefix, directory)\n        os.close(fd)\n        os.chmod(fname, 0o644)\n        return fname"
    },
    {
        "code": "def patch_protocol_for_agent(protocol):\n    old_makeConnection = protocol.makeConnection\n    old_connectionLost = protocol.connectionLost\n    def new_makeConnection(transport):\n        patch_transport_fake_push_producer(transport)\n        patch_transport_abortConnection(transport, protocol)\n        return old_makeConnection(transport)\n    def new_connectionLost(reason):\n        if protocol._fake_connection_aborted and reason.check(ConnectionDone):\n            reason = Failure(ConnectionAborted())\n        return old_connectionLost(reason)\n    protocol.makeConnection = new_makeConnection\n    protocol.connectionLost = new_connectionLost\n    protocol._fake_connection_aborted = False"
    },
    {
        "code": "def cinder(*arg):\n    check_event_type(Openstack.Cinder, *arg)\n    event_type = arg[0]\n    def decorator(func):\n        if event_type.find(\"*\") != -1:\n            event_type_pattern = pre_compile(event_type)\n            cinder_customer_process_wildcard[event_type_pattern] = func\n        else:\n            cinder_customer_process[event_type] = func\n        log.info(\"add function {0} to process event_type:{1}\".format(func.__name__, event_type))\n        @functools.wraps(func)\n        def wrapper(*args, **kwargs):\n            func(*args, **kwargs)\n        return wrapper\n    return decorator"
    },
    {
        "code": "def formalize(self):\n        source_class = self.source_link.to_metaclass\n        target_class = self.target_link.to_metaclass\n        source_class.referential_attributes |= set(self.source_keys)\n        target_class.identifying_attributes |= set(self.target_keys)\n        def fget(inst, ref_name, alt_prop):\n            other_inst = self.target_link.navigate_one(inst)\n            if other_inst is None and alt_prop:\n                return alt_prop.fget(inst)\n            return getattr(other_inst, ref_name, None)\n        def fset(inst, value, name, ref_name, alt_prop):\n            kind = get_metaclass(inst).kind\n            raise MetaException('%s.%s is a referential attribute '\\\n                                'and cannot be assigned directly'% (kind, name))\n        for ref_key, primary_key in zip(self.source_keys, self.target_keys):\n            prop = getattr(source_class.clazz, ref_key, None)\n            prop = property(partial(fget, ref_name=primary_key, alt_prop=prop), \n                            partial(fset, name=ref_key, ref_name=primary_key, alt_prop=prop))\n            setattr(source_class.clazz, ref_key, prop)"
    },
    {
        "code": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):\n        local_stream = utils.BytearrayStream()\n        if self._unique_identifier:\n            self._unique_identifier.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._cryptographic_parameters:\n            self._cryptographic_parameters.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._data:\n            self._data.write(local_stream, kmip_version=kmip_version)\n        if self._digested_data:\n            self._digested_data.write(local_stream, kmip_version=kmip_version)\n        if self._signature_data:\n            self._signature_data.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._correlation_value:\n            self._correlation_value.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._init_indicator:\n            self._init_indicator.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._final_indicator:\n            self._final_indicator.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        self.length = local_stream.length()\n        super(SignatureVerifyRequestPayload, self).write(\n            output_stream,\n            kmip_version=kmip_version\n        )\n        output_stream.write(local_stream.buffer)"
    },
    {
        "code": "def get_imap_capabilities(server):\n    capabilities = list(map(str, list(server.capabilities())))\n    for i in range(len(capabilities)):\n        capabilities[i] = str(capabilities[i]).replace(\"b'\",\n                                                       \"\").replace(\"'\",\n                                                                   \"\")\n    logger.debug(\"IMAP server supports: {0}\".format(capabilities))\n    return capabilities"
    },
    {
        "code": "def get_prices(self, date: str, currency: str) -> List[PriceModel]:\n        from .repositories import PriceRepository\n        session = self.session\n        repo = PriceRepository(session)\n        query = repo.query\n        if date:\n            query = query.filter(dal.Price.date == date)\n        if currency:\n            query = query.filter(dal.Price.currency == currency)\n        query = query.order_by(dal.Price.namespace, dal.Price.symbol)\n        price_entities = query.all()\n        mapper = mappers.PriceMapper()\n        result = []\n        for entity in price_entities:\n            model = mapper.map_entity(entity)\n            result.append(model)\n        return result"
    },
    {
        "code": "def _handle_display_data(self, msg):\n        self.log.debug(\"display: %s\", msg.get('content', ''))\n        if not self._hidden and self._is_from_this_session(msg):\n            source = msg['content']['source']\n            data = msg['content']['data']\n            metadata = msg['content']['metadata']\n            if data.has_key('text/html'):\n                html = data['text/html']\n                self._append_html(html, True)\n            elif data.has_key('text/plain'):\n                text = data['text/plain']\n                self._append_plain_text(text, True)\n            self._append_plain_text(u'\\n', True)"
    },
    {
        "code": "def check_type(self, value):\n        if self.__dict__['dtype'] is None:\n            return\n        elif value is None:\n            return\n        elif isinstance(value, self.__dict__['dtype']):\n            return\n        msg = \"Value of type %s, when %s was expected.\" % (\n            type(value), self.__dict__['dtype'])\n        raise TypeError(msg)"
    },
    {
        "code": "def s3walk(self, basedir, show_dir=None):\n    if not show_dir:\n      show_dir = self.opt.show_dir\n    if basedir[-1] == PATH_SEP:\n      basedir = basedir[0:-1]\n    s3url = S3URL(basedir)\n    result = []\n    pool = ThreadPool(ThreadUtil, self.opt)\n    pool.s3walk(s3url, s3url.get_fixed_path(), s3url.path, result)\n    pool.join()\n    if not show_dir and len(result) == 1 and result[0]['is_dir']:\n      path = result[0]['name']\n      s3url = S3URL(path)\n      result = []\n      pool = ThreadPool(ThreadUtil, self.opt)\n      pool.s3walk(s3url, s3url.get_fixed_path(), s3url.path, result)\n      pool.join()\n    def compare(x, y):\n      result = -cmp(x['is_dir'], y['is_dir'])\n      if result != 0:\n        return result\n      return cmp(x['name'], y['name'])\n    return sorted(result, key=cmp_to_key(compare))"
    },
    {
        "code": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):\n        local_buffer = utils.BytearrayStream()\n        if self._unique_identifier:\n            self._unique_identifier.write(\n                local_buffer,\n                kmip_version=kmip_version\n            )\n        self.length = local_buffer.length()\n        super(GetAttributeListRequestPayload, self).write(\n            output_buffer,\n            kmip_version=kmip_version\n        )\n        output_buffer.write(local_buffer.buffer)"
    },
    {
        "code": "def _construct_schema(elements, nsmap):\n    schema = {\n        'properties': {},\n        'geometry': None\n    }\n    schema_key = None\n    gml_key = None\n    if nsmap:\n        for key in nsmap:\n            if nsmap[key] == XS_NAMESPACE:\n                schema_key = key\n            if nsmap[key] in GML_NAMESPACES:\n                gml_key = key\n    else:\n        gml_key = 'gml'\n        schema_key = 'xsd'\n    mappings = {\n        'PointPropertyType': 'Point',\n        'PolygonPropertyType': 'Polygon',\n        'LineStringPropertyType': 'LineString',\n        'MultiPointPropertyType': 'MultiPoint',\n        'MultiLineStringPropertyType': 'MultiLineString',\n        'MultiPolygonPropertyType': 'MultiPolygon',\n        'MultiGeometryPropertyType': 'MultiGeometry',\n        'GeometryPropertyType': 'GeometryCollection',\n        'SurfacePropertyType': '3D Polygon',\n        'MultiSurfacePropertyType': '3D MultiPolygon'\n    }\n    for element in elements:\n        data_type = element.attrib['type'].replace(gml_key + ':', '')\n        name = element.attrib['name']\n        if data_type in mappings:\n            schema['geometry'] = mappings[data_type]\n            schema['geometry_column'] = name\n        else:\n            schema['properties'][name] = data_type.replace(schema_key+':', '')\n    if schema['properties'] or schema['geometry']:\n        return schema\n    else:\n        return None"
    },
    {
        "code": "def _exit_gracefully(self, signum, frame):\n        self.log.info(\"Exiting gracefully upon receiving signal %s\", signum)\n        self.terminate()\n        self.end()\n        self.log.debug(\"Finished terminating DAG processors.\")\n        sys.exit(os.EX_OK)"
    },
    {
        "code": "def convertArgsToTokens(self, data):\n        tdict = []\n        tokens = []\n        d = open(data, 'r')\n        for line in d.readlines():\n            tdict.append(line.rstrip())\n            tokens += line.split()\n        d.close()\n        tokens = list(set(tokens))\n        return tdict, tokens"
    },
    {
        "code": "def _nested_convert_to_tensor(struct, dtype=None, name=None):\n  if dtype is not None or not tf.nest.is_nested(struct):\n    return tf.convert_to_tensor(struct, dtype=dtype)\n  if _maybe_convertible_to_tensor(struct):\n    try:\n      return tf.convert_to_tensor(value=struct, name=name)\n    except (ValueError, TypeError):\n      pass\n  shallow_struct = _get_shallow_structure(struct)\n  return nest.map_structure_up_to(\n      shallow_struct, lambda s: _nested_convert_to_tensor(s, name=name), struct)"
    },
    {
        "code": "def __get_or_create(\n        ns_cache: NamespaceMap,\n        name: sym.Symbol,\n        module: types.ModuleType = None,\n        core_ns_name=CORE_NS,\n    ) -> lmap.Map:\n        ns = ns_cache.entry(name, None)\n        if ns is not None:\n            return ns_cache\n        new_ns = Namespace(name, module=module)\n        if name.name != core_ns_name:\n            core_ns = ns_cache.entry(sym.symbol(core_ns_name), None)\n            assert core_ns is not None, \"Core namespace not loaded yet!\"\n            new_ns.refer_all(core_ns)\n        return ns_cache.assoc(name, new_ns)"
    },
    {
        "code": "def gauss(x, *p):\n    A, mu, sigma = p\n    return A * np.exp(-0.5 * (-mu + x)**2 / sigma**2)"
    },
    {
        "code": "def tempfile_set(tempfile, target):\n  if target:\n    os.rename(tempfile, target)\n  else:\n    os.unlink(tempfile)\n  if target in TEMP_FILES:\n    TEMP_FILES.remove(tempfile)"
    },
    {
        "code": "def _get_properties(config):\n    property_classes = {BUILTIN_PROPERTY}\n    property_names = set()\n    if config is not None:\n        property_classes.update(config.property_classes)\n        property_names.update(\n            (prop.rsplit(\".\", 1)[-1] for prop in config.property_classes)\n        )\n    return property_classes, property_names"
    },
    {
        "code": "def duration(self):\n        ecc = self.ecc if not np.isnan(self.ecc) else np.sqrt(self.ecw**2 + self.esw**2)\n        esw = self.esw if not np.isnan(self.esw) else ecc * np.sin(self.w)\n        aRs = ((G * self.rhos * (1. + self.MpMs) * \n              (self.per * DAYSEC)**2.) / (3. * np.pi))**(1./3.)\n        inc = np.arccos(self.bcirc/aRs)\n        becc = self.bcirc * (1 - ecc**2)/(1 - esw)\n        tdur = self.per / 2. / np.pi * np.arcsin(((1. + self.RpRs)**2 -\n               becc**2)**0.5 / (np.sin(inc) * aRs))\n        tdur *= np.sqrt(1. - ecc**2.)/(1. - esw)\n        return tdur"
    },
    {
        "code": "def __fetch_items(self, path, page=1):\n        fetch_data = True\n        parsed_crates = 0\n        total_crates = 0\n        while fetch_data:\n            logger.debug(\"Fetching page: %i\", page)\n            try:\n                payload = {'sort': 'alphabetical', 'page': page}\n                raw_content = self.fetch(path, payload=payload)\n                content = json.loads(raw_content)\n                parsed_crates += len(content['crates'])\n                if not total_crates:\n                    total_crates = content['meta']['total']\n            except requests.exceptions.HTTPError as e:\n                logger.error(\"HTTP exception raised - %s\", e.response.text)\n                raise e\n            yield raw_content\n            page += 1\n            if parsed_crates >= total_crates:\n                fetch_data = False"
    },
    {
        "code": "def _joint_mean(self):\n    with tf.name_scope(\"mean_joint\"):\n      with tf.control_dependencies(self.runtime_assertions):\n        initial_latent_mean = _broadcast_to_shape(\n            self.initial_state_prior.mean()[..., tf.newaxis],\n            tf.concat([self.batch_shape_tensor(),\n                       [self.latent_size, 1]], axis=0))\n      initial_observation_mean = _propagate_mean(\n          initial_latent_mean,\n          self.get_observation_matrix_for_timestep(self.initial_step),\n          self.get_observation_noise_for_timestep(self.initial_step))\n      mean_step = build_kalman_mean_step(\n          self.get_transition_matrix_for_timestep,\n          self.get_transition_noise_for_timestep,\n          self.get_observation_matrix_for_timestep,\n          self.get_observation_noise_for_timestep)\n      (latent_means, observation_means) = tf.scan(\n          mean_step,\n          elems=tf.range(self.initial_step+1, self.final_step),\n          initializer=(initial_latent_mean, initial_observation_mean))\n      latent_means = tf.concat([initial_latent_mean[tf.newaxis, ...],\n                                latent_means], axis=0)\n      observation_means = tf.concat([initial_observation_mean[tf.newaxis, ...],\n                                     observation_means], axis=0)\n      latent_means = tf.squeeze(latent_means, -1)\n      latent_means = distribution_util.move_dimension(latent_means, 0, -2)\n      observation_means = tf.squeeze(observation_means, -1)\n      observation_means = distribution_util.move_dimension(\n          observation_means, 0, -2)\n      return latent_means, observation_means"
    },
    {
        "code": "def resolve_outputs(self):\n        input_shape = None\n        for i, shape in enumerate(self._input_shapes.values()):\n            if i == 0:\n                input_shape = shape\n            if len(input_shape) != len(shape) or any(\n                    a is not None and b is not None and a != b\n                    for a, b in zip(input_shape[:-1], shape[:-1])):\n                raise util.ConfigurationError(\n                    'layer \"{}\" incompatible input shapes {}'\n                    .format(self.name, self._input_shapes))\n        size = self.kwargs.get('size')\n        shape = self.kwargs.get('shape')\n        if shape is not None:\n            pass\n        elif size is not None:\n            shape = tuple(input_shape[:-1]) + (size, )\n        else:\n            raise util.ConfigurationError(\n                'layer \"{}\" does not specify a size'.format(self.name))\n        self._output_shapes['out'] = shape"
    },
    {
        "code": "def read(self, filename):\n        kwargs = {}\n        if sys.version_info >= (3, 2):\n            kwargs['encoding'] = \"utf-8\"\n        return configparser.RawConfigParser.read(self, filename, **kwargs)"
    },
    {
        "code": "def normalize(self, dt, is_dst=False):\n        if dt.tzinfo is None:\n            raise ValueError('Naive time - no tzinfo set')\n        return dt.replace(tzinfo=self)"
    },
    {
        "code": "def close(self):\n        if self._closed:\n            return\n        self._socket.close()\n        self._closed = True"
    },
    {
        "code": "def add_patches(self, patches, after=None):\n        if after is None:\n            self.insert_patches(patches)\n        else:\n            self._check_patch(after)\n            patchlines = self._patchlines_before(after)\n            patchlines.append(self.patch2line[after])\n            for patch in patches:\n                patchline = PatchLine(patch)\n                patchlines.append(patchline)\n                self.patch2line[patchline.get_patch()] = patchline\n            patchlines.extend(self._patchlines_after(after))\n            self.patchlines = patchlines"
    },
    {
        "code": "def update_key(\n            self, vault_base_url, key_name, key_version, key_ops=None, key_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):\n        parameters = models.KeyUpdateParameters(key_ops=key_ops, key_attributes=key_attributes, tags=tags)\n        url = self.update_key.metadata['url']\n        path_format_arguments = {\n            'vaultBaseUrl': self._serialize.url(\"vault_base_url\", vault_base_url, 'str', skip_quote=True),\n            'key-name': self._serialize.url(\"key_name\", key_name, 'str'),\n            'key-version': self._serialize.url(\"key_version\", key_version, 'str')\n        }\n        url = self._client.format_url(url, **path_format_arguments)\n        query_parameters = {}\n        query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n        header_parameters = {}\n        header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n        if self.config.generate_client_request_id:\n            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n        if custom_headers:\n            header_parameters.update(custom_headers)\n        if self.config.accept_language is not None:\n            header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n        body_content = self._serialize.body(parameters, 'KeyUpdateParameters')\n        request = self._client.patch(url, query_parameters)\n        response = self._client.send(\n            request, header_parameters, body_content, stream=False, **operation_config)\n        if response.status_code not in [200]:\n            raise models.KeyVaultErrorException(self._deserialize, response)\n        deserialized = None\n        if response.status_code == 200:\n            deserialized = self._deserialize('KeyBundle', response)\n        if raw:\n            client_raw_response = ClientRawResponse(deserialized, response)\n            return client_raw_response\n        return deserialized"
    },
    {
        "code": "def specific_gains(string):\n    if not string:\n        return {}\n    gains = {}\n    for gain in string.split(','):\n        amp_name, value = gain.split('=')\n        gains[amp_name.strip()] = float(value.strip())\n    return gains"
    },
    {
        "code": "def _with_loc(f: W) -> W:\n    @functools.wraps(f)\n    def with_lineno_and_col(ctx):\n        meta = lmap.map(\n            {READER_LINE_KW: ctx.reader.line, READER_COL_KW: ctx.reader.col}\n        )\n        v = f(ctx)\n        try:\n            return v.with_meta(meta)\n        except AttributeError:\n            return v\n    return cast(W, with_lineno_and_col)"
    },
    {
        "code": "def updates(self, **kwargs):\n        regs = regularizers.from_kwargs(self, **kwargs)\n        _, updates = self.build_graph(regs)\n        return updates"
    },
    {
        "code": "def sqrt(wave):\n    r\n    dep_units = \"{0}**0.5\".format(wave.dep_units)\n    return _operation(wave, \"sqrt\", dep_units, np.sqrt)"
    },
    {
        "code": "def parse_args():\n    usage = \"Usage: create_concordance <infile> [<outfile>]\"\n    description = \"Simple Concordance Generator\"\n    argparser = argparse.ArgumentParser(\n        usage=usage, description=description)\n    argparser.add_argument(\n        'infile', type=argparse.FileType('r'),\n        help=\"File read in to create concordance\")\n    argparser.add_argument(\n        'outfile', nargs='?', type=argparse.FileType('w'),\n        default=sys.stdout, help=\"File to write concordance to.  \"\n        \"Default is stdout\")\n    argparser.add_argument(\n        '--word', nargs=\"?\", const=str, help=\"Display a word in concordance\")\n    args = argparser.parse_args()\n    return args"
    },
    {
        "code": "def _count_table_rows(self, table_name):\n        cursor = self._db.cursor()\n        select_stmt = \"SELECT COUNT(*) FROM \" + table_name\n        try:\n            cursor.execute(select_stmt)\n            row = cursor.fetchone()\n        except sqlite3.DatabaseError as e:\n            msg = \"invalid archive file; cause: %s\" % str(e)\n            raise ArchiveError(cause=msg)\n        finally:\n            cursor.close()\n        return row[0]"
    },
    {
        "code": "def discount_status(request, form):\n    discounts = form.cleaned_data[\"discount\"]\n    items = commerce.DiscountItem.objects.filter(\n        Q(discount__in=discounts),\n    ).select_related(\"cart\", \"product\", \"product__category\")\n    items = group_by_cart_status(\n        items,\n        [\"discount\"],\n        [\"discount\", \"discount__description\"],\n    )\n    headings = [\n        \"Discount\", \"Paid\", \"Reserved\", \"Unreserved\", \"Refunded\",\n    ]\n    data = []\n    for item in items:\n        data.append([\n            item[\"discount__description\"],\n            item[\"total_paid\"],\n            item[\"total_reserved\"],\n            item[\"total_unreserved\"],\n            item[\"total_refunded\"],\n        ])\n    return ListReport(\"Usage by item\", headings, data)"
    },
    {
        "code": "def spin(self):\n        if self._notification_socket:\n            self._flush_notifications()\n        if self._iopub_socket:\n            self._flush_iopub(self._iopub_socket)\n        if self._mux_socket:\n            self._flush_results(self._mux_socket)\n        if self._task_socket:\n            self._flush_results(self._task_socket)\n        if self._control_socket:\n            self._flush_control(self._control_socket)\n        if self._query_socket:\n            self._flush_ignored_hub_replies()"
    },
    {
        "code": "def show(self, title=''):\n        self.render(title=title)\n        if self.fig:\n            plt.show(self.fig)"
    },
    {
        "code": "def f_get_groups(self, copy=True):\n        if copy:\n            return self._groups.copy()\n        else:\n            return self._groups"
    },
    {
        "code": "def create_domain(self, domain_name, username=None, alphabet=Domain.DEFAULT_ALPHABET,\n            length=Domain.DEFAULT_KEY_LENGTH):\n        try:\n            return self._create_domain(domain_name, username, alphabet, length)\n        except Exception as ex:\n            _logger.warn(\"Inserting new domain failed: %s\", ex)\n            raise DuplicateDomainException"
    },
    {
        "code": "def get_help(self):\n        if self.help:\n            return self.help\n        elif self.__doc__ and self.__doc__.strip():\n            return self.__doc__.strip()\n        else:\n            return ''"
    },
    {
        "code": "def _unique_constraint_name(table: str, field, keys):\n        postfix = '_'.join(keys)\n        return '{table}_{field}_unique_{postfix}'.format(\n            table=table,\n            field=field.column,\n            postfix=postfix\n        )"
    },
    {
        "code": "def get_result(self, indices_or_msg_ids=None, block=None):\n        block = self.block if block is None else block\n        if indices_or_msg_ids is None:\n            indices_or_msg_ids = -1\n        if not isinstance(indices_or_msg_ids, (list,tuple)):\n            indices_or_msg_ids = [indices_or_msg_ids]\n        theids = []\n        for id in indices_or_msg_ids:\n            if isinstance(id, int):\n                id = self.history[id]\n            if not isinstance(id, basestring):\n                raise TypeError(\"indices must be str or int, not %r\"%id)\n            theids.append(id)\n        local_ids = filter(lambda msg_id: msg_id in self.history or msg_id in self.results, theids)\n        remote_ids = filter(lambda msg_id: msg_id not in local_ids, theids)\n        if remote_ids:\n            ar = AsyncHubResult(self, msg_ids=theids)\n        else:\n            ar = AsyncResult(self, msg_ids=theids)\n        if block:\n            ar.wait()\n        return ar"
    },
    {
        "code": "def load_python_global(module, name):\n    if module == '__builtin__' and six.PY3:\n        module = 'builtins'\n    module = importlib.import_module(module)\n    return getattr(module, name)"
    },
    {
        "code": "def _req_rep_retry(self, request):\n        retries_left = self.RETRIES\n        while retries_left:\n            self._logger.log(1, 'Sending REQ `%s`', request)\n            self._send_request(request)\n            socks = dict(self._poll.poll(self.TIMEOUT))\n            if socks.get(self._socket) == zmq.POLLIN:\n                response = self._receive_response()\n                self._logger.log(1, 'Received REP `%s`', response)\n                return response, self.RETRIES - retries_left\n            else:\n                self._logger.debug('No response from server (%d retries left)' %\n                                   retries_left)\n                self._close_socket(confused=True)\n                retries_left -= 1\n                if retries_left == 0:\n                    raise RuntimeError('Server seems to be offline!')\n                time.sleep(self.SLEEP)\n                self._start_socket()"
    },
    {
        "code": "def _check_inputs(self):\n        try:\n            _ = self._inputs[0]\n        except TypeError:\n            raise RuntimeError(\n                \"inputs should be iterable but found type='{0}', value=\"\n                \"'{1}'\".format(type(self._inputs), str(self._inputs)))\n        from melody.inputs import Input\n        for check_input in self._inputs:\n            if not isinstance(check_input, Input):\n                raise RuntimeError(\n                    \"input should be a subclass of the Input class but \"\n                    \"found type='{0}', value='{1}'\".format(type(check_input),\n                                                           str(check_input)))"
    },
    {
        "code": "def individuals(context, institute, causatives, case_id):\n    LOG.info(\"Running scout view individuals\")\n    adapter = context.obj['adapter']\n    individuals = []\n    if case_id:\n        case = adapter.case(case_id=case_id)\n        if case:\n            cases = [case]\n        else:\n            LOG.info(\"Could not find case %s\", case_id)\n            return\n    else:\n        cases = [case_obj for case_obj in\n                 adapter.cases(\n                     collaborator=institute,\n                     has_causatives=causatives)]\n        if len(cases) == 0:\n            LOG.info(\"Could not find cases that match criteria\")\n            return\n        individuals = (ind_obj for case_obj in cases for ind_obj in case_obj['individuals'])\n    click.echo(\"\n    for case in cases:\n        for ind_obj in case['individuals']:\n            ind_info = [\n                case['_id'], ind_obj['individual_id'],\n                ind_obj['display_name'], SEX_MAP[int(ind_obj['sex'])],\n                PHENOTYPE_MAP[ind_obj['phenotype']], ind_obj['mother'],\n                ind_obj['father']\n            ]\n            click.echo('\\t'.join(ind_info))"
    },
    {
        "code": "def show(self, *args, **kwargs):\n        from webbrowser import open as webopen\n        return webopen(str(self), *args, **kwargs)"
    },
    {
        "code": "def insert_child ( self, object, index, child ):\n        if isinstance( child, Subgraph ):\n            object.subgraphs.insert( index, child )\n        elif isinstance( child, Cluster ):\n            object.clusters.insert( index, child )\n        elif isinstance( child, Node ):\n            object.nodes.insert( index, child )\n        elif isinstance( child, Edge ):\n            object.edges.insert( index, child )\n        else:\n            pass"
    },
    {
        "code": "def get_private_keys(\n            self,\n            index=0,\n            count=1,\n            security_level=AddressGenerator.DEFAULT_SECURITY_LEVEL,\n    ):\n        return commands.GetPrivateKeysCommand(self.adapter)(\n            seed=self.seed,\n            index=index,\n            count=count,\n            securityLevel=security_level,\n        )"
    },
    {
        "code": "async def limited(until):\n    duration = int(round(until - time.time()))\n    mins = duration / 60\n    fmt = 'We have exhausted a ratelimit quota. Retrying in %.2f seconds (%.3f minutes).'\n    log.warn(fmt, duration, mins)"
    },
    {
        "code": "def get_last_activities(self, n):\n        filenames = self.get_activity_list().iloc[-n:].filename.tolist()\n        last_activities = [self.get_activity(f) for f in filenames]\n        return last_activities"
    },
    {
        "code": "def fetch(self, category=CATEGORY_QUESTION, offset=DEFAULT_OFFSET):\n        if not offset:\n            offset = DEFAULT_OFFSET\n        kwargs = {\"offset\": offset}\n        items = super().fetch(category, **kwargs)\n        return items"
    },
    {
        "code": "def get_public_tokens(self):\n        r = self.remote_utils.get_url(self.url() + \"public_tokens/\")\n        return r.json()"
    },
    {
        "code": "def validate_token(self, token, expected_data=None):\n        try:\n            data = self.load_token(token)\n            if expected_data:\n                for k in expected_data:\n                    if expected_data[k] != data[\"data\"].get(k):\n                        return None\n            return data\n        except BadData:\n            return None"
    },
    {
        "code": "async def set_session_state(self, state):\n        await self._can_run()\n        state = state.encode(self.encoding) if isinstance(state, six.text_type) else state\n        return await self._mgmt_request_response(\n            REQUEST_RESPONSE_SET_SESSION_STATE_OPERATION,\n            {'session-id': self.session_id, 'session-state': bytearray(state)},\n            mgmt_handlers.default)"
    },
    {
        "code": "def error(self, relative_to='AME2003'):\n        df = self.df - Table(relative_to).df\n        return Table(df=df)"
    },
    {
        "code": "def update_event_hub(self, hub_name, hub=None):\n        _validate_not_none('hub_name', hub_name)\n        request = HTTPRequest()\n        request.method = 'PUT'\n        request.host = self._get_host()\n        request.path = '/' + _str(hub_name) + '?api-version=2014-01'\n        request.body = _get_request_body(_convert_event_hub_to_xml(hub))\n        request.path, request.query = self._httpclient._update_request_uri_query(request)\n        request.headers.append(('If-Match', '*'))\n        request.headers = self._update_service_bus_header(request)\n        response = self._perform_request(request)\n        return _convert_response_to_event_hub(response)"
    },
    {
        "code": "def _get_pipeline_processes(self):\n        with open(self.log_file) as fh:\n            for line in fh:\n                if re.match(\".*Creating operator.*\", line):\n                    match = re.match(\".*Creating operator > (.*) --\", line)\n                    process = match.group(1)\n                    if any([process.startswith(x) for x in self._blacklist]):\n                        continue\n                    if process not in self.skip_processes:\n                        self.processes[match.group(1)] = {\n                            \"barrier\": \"W\",\n                            \"submitted\": set(),\n                            \"finished\": set(),\n                            \"failed\": set(),\n                            \"retry\": set(),\n                            \"cpus\": None,\n                            \"memory\": None\n                        }\n                        self.process_tags[process] = {}\n                if re.match(\".*Launching `.*` \\[.*\\] \", line):\n                    tag_match = re.match(\".*Launching `.*` \\[(.*)\\] \", line)\n                    self.pipeline_tag = tag_match.group(1) if tag_match else \\\n                        \"?\"\n                    name_match = re.match(\".*Launching `(.*)` \\[.*\\] \", line)\n                    self.pipeline_name = name_match.group(1) if name_match \\\n                        else \"?\"\n        self.content_lines = len(self.processes)"
    },
    {
        "code": "def allow_request(self, request, view):\n        if request.method != 'POST':\n            return True\n        return super(PostRequestThrottleMixin, self).allow_request(request, view)"
    },
    {
        "code": "def mr_reader(job, input_stream, loads=core.loads):\n    for line in input_stream:\n        yield loads(line),"
    },
    {
        "code": "def until_traits_are_present(self, element_with_traits):\n        end_time = time.time() + self._timeout\n        count = 1\n        missing_traits_descriptions = None\n        while True:\n            missing_traits_descriptions = []\n            try:\n                missing_traits_descriptions = element_with_traits.evaluate_traits()\n                if len(missing_traits_descriptions) == 0:\n                    return True\n                else:\n                    logger.debug(\"\n                        missing_traits_descriptions)))\n            except self._ignored_exceptions as ex:\n                logger.debug(\"Captured {0}: {1}\".format(str(ex.__class__).replace(\"<type '\", \"\").replace(\"'>\", \"\"),\n                                                        str(ex)))\n                pass\n            time.sleep(self._poll)\n            count += 1\n            if time.time() > end_time:\n                break\n        raise TimeoutException(\n            msg=\"conditions \" + '<' + '> <'.join(missing_traits_descriptions) + '>' + \" not true after \" + str(\n                self._timeout) + \" seconds.\")"
    },
    {
        "code": "def find_max_rad_npnp(self):\n        max_rad = 0\n        max_npnp = 0\n        for res, _ in self.items():\n            if res != 'KEY':\n                for _, ff_params in self[res].items():\n                    if max_rad < ff_params[1]:\n                        max_rad = ff_params[1]\n                    if max_npnp < ff_params[4]:\n                        max_npnp = ff_params[4]\n        return max_rad, max_npnp"
    },
    {
        "code": "def crscode_to_string(codetype, code, format):\n    link = 'http://spatialreference.org/ref/%s/%s/%s/' %(codetype,code,format)\n    result = urllib2.urlopen(link).read()\n    if not isinstance(result, str):\n        result = result.decode()\n    return result"
    },
    {
        "code": "def intern(self, sym: sym.Symbol, var: Var, force: bool = False) -> Var:\n        m: lmap.Map = self._interns.swap(Namespace._intern, sym, var, force=force)\n        return m.entry(sym)"
    },
    {
        "code": "def clone(url, path):\n    adapter = None\n    if url[:4] == \"git@\" or url[-4:] == \".git\":\n        adapter = Git(path)\n    if url[:6] == \"svn://\":\n        adapter = Svn(path)\n    if url[:6] == \"bzr://\":\n        adapter = Bzr(path)\n    if url[:9] == \"ssh://hg@\":\n        adapter = Hg(path)\n    if adapter is None:\n        raise RepositoryAdapterNotFound(\n            \"Can't find adapter for `%s` repository url\" % url)\n    return adapter.clone(url)"
    },
    {
        "code": "def _send_file(self, local, remote):\n        remote = \"%s:%s\" % (self.location, remote)\n        for i in range(10):\n            if not os.path.exists(local):\n                self.log.debug(\"waiting for %s\" % local)\n                time.sleep(1)\n            else:\n                break\n        self.log.info(\"sending %s to %s\", local, remote)\n        check_output(self.scp_cmd + [local, remote])"
    },
    {
        "code": "def set_default_tlw(self, tlw, designer, inspector):\n        \"track default top level window for toolbox menu default action\"\n        self.designer = designer\n        self.inspector = inspector"
    },
    {
        "code": "def _chunk_pars(freq_vector, data_matrix, pformat):\n    pformat = pformat.upper()\n    length = 4\n    for freq, data in zip(freq_vector, data_matrix):\n        data = data.flatten()\n        for index in range(0, data.size, length):\n            fpoint = [freq] if not index else [None]\n            cdata = data[index : index + length]\n            if pformat == \"MA\":\n                vector1 = np.abs(cdata)\n                vector2 = np.rad2deg(np.angle(cdata))\n            elif pformat == \"RI\":\n                vector1 = np.real(cdata)\n                vector2 = np.imag(cdata)\n            else:\n                vector1 = 20.0 * np.log10(np.abs(cdata))\n                vector2 = np.rad2deg(np.angle(cdata))\n            sep_data = np.array([])\n            for item1, item2 in zip(vector1, vector2):\n                sep_data = np.concatenate((sep_data, np.array([item1, item2])))\n            ret = np.concatenate((np.array(fpoint), sep_data))\n            yield ret"
    },
    {
        "code": "def _determine_function_name_type(node, config=None):\n    property_classes, property_names = _get_properties(config)\n    if not node.is_method():\n        return \"function\"\n    if node.decorators:\n        decorators = node.decorators.nodes\n    else:\n        decorators = []\n    for decorator in decorators:\n        if isinstance(decorator, astroid.Name) or (\n            isinstance(decorator, astroid.Attribute)\n            and decorator.attrname in property_names\n        ):\n            infered = utils.safe_infer(decorator)\n            if infered and infered.qname() in property_classes:\n                return \"attr\"\n        elif isinstance(decorator, astroid.Attribute) and decorator.attrname in (\n            \"setter\",\n            \"deleter\",\n        ):\n            return \"attr\"\n    return \"method\""
    },
    {
        "code": "def get(self, name, factory, *factory_args, **factory_kwargs):\n        update_thread_local = getattr(factory, 'update_thread_local', True)\n        if (not update_thread_local) or (name not in self.__dict__):\n            obj = factory(*factory_args, **factory_kwargs)\n            if update_thread_local:\n                setattr(self, name, obj)\n            return obj\n        return getattr(self, name)"
    },
    {
        "code": "def _build_point_formats_dtypes(point_format_dimensions, dimensions_dict):\n    return {\n        fmt_id: _point_format_to_dtype(point_fmt, dimensions_dict)\n        for fmt_id, point_fmt in point_format_dimensions.items()\n    }"
    },
    {
        "code": "def fetch_metric(self, metric, start, end, tags={}, aggregator=\"sum\",\n        downsample=None, ms_resolution=True):\n        query = \"{aggregator}:{downsample}{metric}{{{tags}}}\".format(\n            aggregator=aggregator,\n            downsample=downsample + \"-avg:\" if downsample else \"\",\n            metric=metric,\n            tags=','.join(\"%s=%s\" % (k, v) for k, v in tags.items())\n        )\n        params = {\n            'ms': ms_resolution,\n            'start': '{0:.3f}'.format(start.timestamp()),\n            'end': '{0:.3f}'.format(end.timestamp()),\n            'm': query\n        }\n        response = self.__request(\"/query\", params)\n        if response.status_code == 200:\n            try:\n                return response.json()[0]['dps']\n            except IndexError:\n                return {}\n        raise QueryError(response.json())"
    },
    {
        "code": "def read(self):\n        self.__fileobj.seek(self.data_offset)\n        self.data = self.__fileobj.read(self.data_size)"
    },
    {
        "code": "def gen_timeout_resend(attempts):\n    timeout = 2 ** (attempts + 1) + random.uniform(-1, +1)\n    logger.debug('next timeout resending will happen on %s',\n                 future_dt_str(nowutc(), timeout))\n    return timeout"
    },
    {
        "code": "def apply(self, method, args):\n        try:\n            params = args['params']\n            if isinstance(params, dict):\n                result = method(**params)\n            else:\n                result = method(*params)\n        except Exception as error:\n            server_error(args['id'], error)\n        else:\n            return result"
    },
    {
        "code": "def _add_group_from_storage(self, args, kwargs):\n        return self._nn_interface._add_generic(self,\n                                                type_name=GROUP,\n                                                group_type_name=GROUP,\n                                                args=args,\n                                                kwargs=kwargs,\n                                                add_prefix=False,\n                                                check_naming=False)"
    },
    {
        "code": "def hflip(img):\n    if not _is_pil_image(img):\n        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n    return img.transpose(Image.FLIP_LEFT_RIGHT)"
    },
    {
        "code": "def save_image(self, imagefile, save_path, file_ext, mime_type):\n        file_to_save = InMemoryUploadedFile(\n            imagefile,\n            None,\n            'foo.%s' % file_ext,\n            mime_type,\n            imagefile.tell(),\n            None\n        )\n        file_to_save.seek(0)\n        self.storage.save(save_path, file_to_save)"
    },
    {
        "code": "def draw(self):\n        if not self.visible:\n            return\n        if not isinstance(self.submenu,Container):\n            glEnable(GL_SCISSOR_TEST)\n            glScissor(*self.pos+self.size)\n        SubMenu.draw(self)\n        if not isinstance(self.submenu,Container):\n            glDisable(GL_SCISSOR_TEST)"
    },
    {
        "code": "def cb_help_message(self, option, optname, value, parser):\n        self.linter.msgs_store.help_message(utils._splitstrip(value))\n        sys.exit(0)"
    },
    {
        "code": "def open(path, mode=gdalconst.GA_ReadOnly):\n    path = getattr(path, 'name', path)\n    try:\n        return Raster(vsiprefix(path), mode)\n    except AttributeError:\n        try:\n            imgdata = path.read()\n        except AttributeError:\n            raise TypeError('Not a file-like object providing read()')\n        else:\n            imgio = MemFileIO(delete=False)\n            gdal.FileFromMemBuffer(imgio.name, imgdata)\n            return Raster(imgio, mode)\n    raise ValueError('Failed to open raster from \"%r\"' % path)"
    },
    {
        "code": "def from_connection_string(cls, conn_str, *, loop=None, **kwargs):\n        address, policy, key, _ = parse_conn_str(conn_str)\n        parsed_namespace = urlparse(address)\n        namespace, _, base = parsed_namespace.hostname.partition('.')\n        return cls(\n            service_namespace=namespace,\n            shared_access_key_name=policy,\n            shared_access_key_value=key,\n            host_base='.' + base,\n            loop=loop,\n            **kwargs)"
    },
    {
        "code": "def _read_config(self):\n        self._config_loaded = True\n        conf = []\n        for f in self._candidate_log_files():\n            if os.path.isfile(f):\n                self._logger.info(\"Reading config file %s\" % f)\n                section_rx = re.compile(r\"^\\[(\\w+)\\]$\")\n                keyvalue_rx = re.compile(r\"^(\\w+:)?([\\w.]+)\\s*=(.*)$\")\n                with io.open(f, \"rt\", encoding=\"utf-8\") as config_file:\n                    section_name = None\n                    for lineno, line in enumerate(config_file):\n                        line = line.strip()\n                        if line == \"\" or line.startswith(\"\n                        m1 = section_rx.match(line)\n                        if m1:\n                            section_name = m1.group(1)\n                            continue\n                        m2 = keyvalue_rx.match(line)\n                        if m2:\n                            lng = m2.group(1)\n                            key = m2.group(2)\n                            val = m2.group(3).strip()\n                            if lng and lng.lower() != \"py:\": continue\n                            if section_name:\n                                key = section_name + \".\" + key\n                            if key in H2OConfigReader._allowed_config_keys:\n                                conf.append((key, val))\n                            else:\n                                self._logger.error(\"Key %s is not a valid config key\" % key)\n                            continue\n                        self._logger.error(\"Syntax error in config file line %d: %s\" % (lineno, line))\n                self._config = dict(conf)\n                return"
    },
    {
        "code": "def clean_time_slots(self):\n        ts = ((a[0], a[1]) for t in self.tiers.values() for a in t[0].values())\n        for a in {a for b in ts for a in b} ^ set(self.timeslots):\n            del(self.timeslots[a])"
    },
    {
        "code": "def __last_beat(cumscore):\n    maxes = util.localmax(cumscore)\n    med_score = np.median(cumscore[np.argwhere(maxes)])\n    return np.argwhere((cumscore * maxes * 2 > med_score)).max()"
    },
    {
        "code": "def _basename_in_blacklist_re(base_name, black_list_re):\n    for file_pattern in black_list_re:\n        if file_pattern.match(base_name):\n            return True\n    return False"
    },
    {
        "code": "def _parse_header(line):\n    parts = _parseparam(';' + line)\n    key = parts.next()\n    pdict = {}\n    for p in parts:\n        i = p.find('=')\n        if i >= 0:\n            name = p[:i].strip().lower()\n            value = p[i+1:].strip()\n            if len(value) >= 2 and value[0] == value[-1] == '\"':\n                value = value[1:-1]\n                value = value.replace('\\\\\\\\', '\\\\').replace('\\\\\"', '\"')\n            pdict[name] = value\n    return key, pdict"
    },
    {
        "code": "def plot_tree(T, res=None, title=None, cmap_id=\"Pastel2\"):\n    import matplotlib.pyplot as plt\n    def round_time(t, res=0.1):\n        v = int(t / float(res)) * res\n        return v\n    cmap = plt.get_cmap(cmap_id)\n    level_bounds = []\n    for level in T.levels:\n        if level == \"root\":\n            continue\n        segments = T.get_segments_in_level(level)\n        level_bounds.append(segments)\n    B = float(len(level_bounds))\n    for i, segments in enumerate(level_bounds):\n        labels = utils.segment_labels_to_floats(segments)\n        for segment, label in zip(segments, labels):\n            if res is None:\n                start = segment.start\n                end = segment.end\n                xlabel = \"Time (seconds)\"\n            else:\n                start = int(round_time(segment.start, res=res) / res)\n                end = int(round_time(segment.end, res=res) / res)\n                xlabel = \"Time (frames)\"\n            plt.axvspan(start, end,\n                        ymax=(len(level_bounds) - i) / B,\n                        ymin=(len(level_bounds) - i - 1) / B,\n                        facecolor=cmap(label))\n    L = float(len(T.levels) - 1)\n    plt.yticks(np.linspace(0, (L - 1) / L, num=L) + 1 / L / 2.,\n               T.levels[1:][::-1])\n    plt.xlabel(xlabel)\n    if title is not None:\n        plt.title(title)\n    plt.gca().set_xlim([0, end])"
    },
    {
        "code": "def validate_zone(zone):\n    if not has_valid_id(zone):\n        raise InvalidZone(\"%s must contain a valid 'id' attribute\" % zone.__name__)\n    if not has_valid_name(zone):\n        raise InvalidZone(\"%s must contain a valid 'name' attribute\" % zone.__name__)"
    },
    {
        "code": "def _merge(self, old, new, use_equals=False):\n    if old is None:\n      return new\n    if new is None:\n      return old\n    if (old == new) if use_equals else (old is new):\n      return old\n    raise ValueError(\"Incompatible values: %s != %s\" % (old, new))"
    },
    {
        "code": "def list(self, resource=None, type=None, actorId=None, _from=None, to=None,\n             max=None, **request_parameters):\n        check_type(resource, basestring)\n        check_type(type, basestring)\n        check_type(actorId, basestring)\n        check_type(_from, basestring)\n        check_type(to, basestring)\n        check_type(max, int)\n        params = dict_from_items_with_values(\n            request_parameters,\n            resource=resource,\n            type=type,\n            actorId=actorId,\n            _from=_from,\n            to=to,\n            max=max,\n        )\n        if _from:\n            params[\"from\"] = params.pop(\"_from\")\n        items = self._session.get_items(API_ENDPOINT, params=params)\n        for item in items:\n            yield self._object_factory(OBJECT_TYPE, item)"
    },
    {
        "code": "def _reformat_historical_formating_error(self):\n        if PyFunceble.CONFIGURATION[\"inactive_database\"]:\n            historical_formating_error = (\n                PyFunceble.CURRENT_DIRECTORY + \"inactive-db.json\"\n            )\n            if PyFunceble.path.isfile(historical_formating_error):\n                data = Dict().from_json(File(historical_formating_error).read())\n                data_to_parse = {}\n                top_keys = data.keys()\n                for top_key in top_keys:\n                    low_keys = data[top_key].keys()\n                    data_to_parse[top_key] = {}\n                    for low_key in low_keys:\n                        if low_key.isdigit():\n                            data_to_parse[top_key][\n                                int(low_key) - (self.one_day_in_seconds * 30)\n                            ] = data[top_key][low_key]\n                        else:\n                            data_to_parse[top_key][\n                                int(PyFunceble.time()) - (self.one_day_in_seconds * 30)\n                            ] = data[top_key][low_key]\n                if \"inactive_db\" in PyFunceble.INTERN:\n                    PyFunceble.INTERN[\"inactive_db\"].update(data_to_parse)\n                else:\n                    PyFunceble.INTERN[\"inactive_db\"] = data_to_parse\n                File(historical_formating_error).delete()"
    },
    {
        "code": "def _copy_image(self, name):\n        image = self._get_image(name)\n        QtGui.QApplication.clipboard().setImage(image)"
    },
    {
        "code": "def list(self):\n        url = \"api/v0002/mgmt/custom/bundle\"\n        r = self._apiClient.get(url)\n        if r.status_code == 200:\n            return r.json()\n        else:\n            raise ApiException(r)"
    },
    {
        "code": "def log_attempt(self, key):\n        with self.lock:\n            if key not in self.attempts:\n                self.attempts[key] = 1\n            else:\n                self.attempts[key] += 1\n                if self.attempts[key] >= self.max_attempts:\n                    log.info('Account %s locked due to too many login attempts' % key)\n                    self.locks[key] = datetime.datetime.utcnow() + datetime.timedelta(seconds=self.lock_duration)"
    },
    {
        "code": "def get_process_gids(self):\n        real, effective, saved = _psutil_bsd.get_process_gids(self.pid)\n        return nt_gids(real, effective, saved)"
    },
    {
        "code": "def get_service_certificate(self, service_name, thumbalgorithm, thumbprint):\n        _validate_not_none('service_name', service_name)\n        _validate_not_none('thumbalgorithm', thumbalgorithm)\n        _validate_not_none('thumbprint', thumbprint)\n        return self._perform_get(\n            '/' + self.subscription_id + '/services/hostedservices/' +\n            _str(service_name) + '/certificates/' +\n            _str(thumbalgorithm) + '-' + _str(thumbprint) + '',\n            Certificate)"
    },
    {
        "code": "def calc_n_ints_in_file(filename):\n    h = read_header(filename)\n    n_bytes  = int(h[b'nbits'] / 8)\n    n_chans = h[b'nchans']\n    n_ifs   = h[b'nifs']\n    idx_data = len_header(filename)\n    f = open(filename, 'rb')\n    f.seek(idx_data)\n    filesize = os.path.getsize(filename)\n    n_bytes_data = filesize - idx_data\n    if h[b'nbits'] == 2:\n        n_ints = int(4 * n_bytes_data / (n_chans * n_ifs))\n    else:\n        n_ints = int(n_bytes_data / (n_bytes * n_chans * n_ifs))\n    return n_ints"
    },
    {
        "code": "def collect_things_entry_points():\n    things = dict()\n    for entry_point in iter_entry_points(group='invenio_migrator.things'):\n        things[entry_point.name] = entry_point.load()\n    return things"
    },
    {
        "code": "def _check_token_present(self):\n\t\ttry:\n\t\t\tself._get_value(CONFIGKEY_TOKEN)\n\t\t\tself._get_value(CONFIGKEY_REFRESH_TOKEN)\n\t\t\tself._get_value(CONFIGKEY_REFRESHABLE)\n\t\texcept KeyError:\n\t\t\tself._log(\"Request new Token (CTP)\")\n\t\t\tself._get_new_access_information()"
    },
    {
        "code": "def parse(self, *args):\n        parsed_args = self.parser.parse_args(args)\n        if parsed_args.category is None:\n            delattr(parsed_args, 'category')\n        if self._from_date:\n            parsed_args.from_date = str_to_datetime(parsed_args.from_date)\n        if self._to_date and parsed_args.to_date:\n            parsed_args.to_date = str_to_datetime(parsed_args.to_date)\n        if self._archive and parsed_args.archived_since:\n            parsed_args.archived_since = str_to_datetime(parsed_args.archived_since)\n        if self._archive and parsed_args.fetch_archive and parsed_args.no_archive:\n            raise AttributeError(\"fetch-archive and no-archive arguments are not compatible\")\n        if self._archive and parsed_args.fetch_archive and not parsed_args.category:\n            raise AttributeError(\"fetch-archive needs a category to work with\")\n        for alias, arg in self.aliases.items():\n            if (alias not in parsed_args) and (arg in parsed_args):\n                value = getattr(parsed_args, arg, None)\n                setattr(parsed_args, alias, value)\n        return parsed_args"
    },
    {
        "code": "def connection_lost(self, exc):\n        logger.debug(\"worker connection lost\")\n        self._worker.close()\n        self._workers.remove(self._worker)"
    },
    {
        "code": "def register_handler(self, name, handler, esc_strings):\n        self._handlers[name] = handler\n        for esc_str in esc_strings:\n            self._esc_handlers[esc_str] = handler"
    },
    {
        "code": "def get_plugin_option(self, plugin, key):\n        if plugin in self.plugins:\n            plugin = self.plugins[plugin]\n            return plugin.get_option(key)"
    },
    {
        "code": "def release(self):\n        if self.table is None:\n            raise GiraffeError(\"Cannot release. Target table has not been set.\")\n        log.info(\"BulkLoad\", \"Attempting release for table {}\".format(self.table))\n        self.mload.release(self.table)"
    },
    {
        "code": "def get_enumerations_from_bit_mask(enumeration, mask):\n    return [x for x in enumeration if (x.value & mask) == x.value]"
    },
    {
        "code": "def update_w(self):\n        def update_single_w(i):\n            FB = base.matrix(np.float64(np.dot(-self.data.T, W_hat[:,i])))\n            be = solvers.qp(HB, FB, INQa, INQb, EQa, EQb)\n            self.beta[i,:] = np.array(be['x']).reshape((1, self._num_samples))\n        HB = base.matrix(np.float64(np.dot(self.data[:,:].T, self.data[:,:])))\n        EQb = base.matrix(1.0, (1, 1))\n        W_hat = np.dot(self.data, pinv(self.H))\n        INQa = base.matrix(-np.eye(self._num_samples))\n        INQb = base.matrix(0.0, (self._num_samples, 1))\n        EQa = base.matrix(1.0, (1, self._num_samples))\n        for i in range(self._num_bases):\n            update_single_w(i)\n        self.W = np.dot(self.beta, self.data.T).T"
    },
    {
        "code": "def inverse(self):\n        return Snapshot(self.num_qubits, self.num_clbits, self.params[0],\n                        self.params[1])"
    },
    {
        "code": "def prune_all(self) -> int:\n        from .repositories import PriceRepository\n        repo = PriceRepository()\n        items = repo.query.distinct(dal.Price.namespace, dal.Price.symbol).all()\n        count = 0\n        for item in items:\n            symbol = SecuritySymbol(item.namespace, item.symbol)\n            deleted = self.prune(symbol)\n            if deleted:\n                count += 1\n        return count"
    },
    {
        "code": "def _merge_single_runs(self, other_trajectory, used_runs):\n        count = len(self)\n        run_indices = range(len(other_trajectory))\n        run_name_dict = OrderedDict()\n        to_store_groups_with_annotations = []\n        for idx in run_indices:\n            if idx in used_runs:\n                other_info_dict = other_trajectory.f_get_run_information(idx)\n                time_ = other_info_dict['time']\n                timestamp = other_info_dict['timestamp']\n                completed = other_info_dict['completed']\n                short_environment_hexsha = other_info_dict['short_environment_hexsha']\n                finish_timestamp = other_info_dict['finish_timestamp']\n                runtime = other_info_dict['runtime']\n                new_idx = used_runs[idx]\n                new_runname = self.f_wildcard('$', new_idx)\n                run_name_dict[idx] = new_runname\n                info_dict = dict(\n                    idx=new_idx,\n                    time=time_,\n                    timestamp=timestamp,\n                    completed=completed,\n                    short_environment_hexsha=short_environment_hexsha,\n                    finish_timestamp=finish_timestamp,\n                    runtime=runtime)\n                self._add_run_info(**info_dict)"
    },
    {
        "code": "def _get_resource_url(self, url, auto_page, data_key):\n        headers = {'Accept': 'application/json',\n                   'Connection': 'keep-alive'}\n        response = DAO.getURL(url, headers)\n        if response.status != 200:\n            raise DataFailureException(url, response.status, response.data)\n        data = json.loads(response.data)\n        self.next_page_url = self._next_page(response)\n        if auto_page and self.next_page_url:\n            if isinstance(data, list):\n                data.extend(self._get_resource_url(self.next_page_url, True,\n                                                   data_key))\n            elif isinstance(data, dict) and data_key is not None:\n                data[data_key].extend(self._get_resource_url(\n                    self.next_page_url, True, data_key)[data_key])\n        return data"
    },
    {
        "code": "def start_workers(self, workers_per_task=1):\n        if not self.workers:\n            for _ in range(workers_per_task):\n                self.workers.append(Worker(self._download, self.queues['download'], self.queues['convert'], self.stopper))\n                self.workers.append(Worker(self._convert, self.queues['convert'], self.queues['upload'], self.stopper))\n                self.workers.append(Worker(self._upload, self.queues['upload'], self.queues['delete'], self.stopper))\n                self.workers.append(Worker(self._delete, self.queues['delete'], self.queues['done'], self.stopper))\n            self.signal_handler = SignalHandler(self.workers, self.stopper)\n            signal.signal(signal.SIGINT, self.signal_handler)\n            for worker in self.workers:\n                worker.start()"
    },
    {
        "code": "def bind_parameters(self, value_dict):\n        new_circuit = self.copy()\n        if value_dict.keys() > self.parameters:\n            raise QiskitError('Cannot bind parameters ({}) not present in the circuit.'.format(\n                [str(p) for p in value_dict.keys() - self.parameters]))\n        for parameter, value in value_dict.items():\n            new_circuit._bind_parameter(parameter, value)\n        for parameter in value_dict:\n            del new_circuit._parameter_table[parameter]\n        return new_circuit"
    },
    {
        "code": "def _delete_resource(self, url):\n        params = {}\n        self._set_as_user(params)\n        headers = {'Accept': 'application/json',\n                   'Connection': 'keep-alive'}\n        url = url + self._params(params)\n        response = DAO.deleteURL(url, headers)\n        if not (response.status == 200 or response.status == 204):\n            raise DataFailureException(url, response.status, response.data)\n        return response"
    },
    {
        "code": "def process_module(self, node):\n        if self.config.file_header:\n            if sys.version_info[0] < 3:\n                pattern = re.compile(\n                    '\\A' + self.config.file_header, re.LOCALE | re.MULTILINE)\n            else:\n                pattern = re.compile(\n                    '\\A' + self.config.file_header, re.MULTILINE)\n            content = None\n            with node.stream() as stream:\n                content = stream.read().decode('utf-8')\n            matches = pattern.findall(content)\n            if len(matches) != 1:\n                self.add_message('invalid-file-header', 1,\n                                 args=self.config.file_header)"
    },
    {
        "code": "def tree_climber(self, tree_alias, base_item):\n        if base_item is not None:\n            base_item.in_current_branch = True\n            if hasattr(base_item, 'parent') and base_item.parent is not None:\n                self.tree_climber(tree_alias, self.get_item_by_id(tree_alias, base_item.parent.id))"
    },
    {
        "code": "def convert_acquire(self, shift, instruction):\n        meas_level = self._run_config.get('meas_level', 2)\n        command_dict = {\n            'name': 'acquire',\n            't0': shift+instruction.start_time,\n            'duration': instruction.duration,\n            'qubits': [q.index for q in instruction.acquires],\n            'memory_slot': [m.index for m in instruction.mem_slots]\n        }\n        if meas_level == 2:\n            if instruction.command.discriminator:\n                command_dict.update({\n                    'discriminators': [\n                        QobjMeasurementOption(\n                            name=instruction.command.discriminator.name,\n                            params=instruction.command.discriminator.params)\n                    ]\n                })\n            command_dict.update({\n                'register_slot': [regs.index for regs in instruction.reg_slots]\n            })\n        if meas_level >= 1:\n            if instruction.command.kernel:\n                command_dict.update({\n                    'kernels': [\n                        QobjMeasurementOption(\n                            name=instruction.command.kernel.name,\n                            params=instruction.command.kernel.params)\n                    ]\n                })\n        return self._qobj_model(**command_dict)"
    },
    {
        "code": "def getUserId(self):\n        self.userId = self(\"GET\", \"{0}/users/self/profile\".format(self.API_USER),\n                           auth=self.Auth.SkypeToken).json().get(\"username\")"
    },
    {
        "code": "def fields(self, *fields):\n        if len(fields) == 0:\n            return [el.split() for el in self]\n        res = SList()\n        for el in [f.split() for f in self]:\n            lineparts = []\n            for fd in fields:\n                try:\n                    lineparts.append(el[fd])\n                except IndexError:\n                    pass\n            if lineparts:\n                res.append(\" \".join(lineparts))\n        return res"
    },
    {
        "code": "def run_picard_sort(job, bam, sort_by_name=False):\n    work_dir = job.fileStore.getLocalTempDir()\n    job.fileStore.readGlobalFile(bam, os.path.join(work_dir, 'input.bam'))\n    command = ['SortSam',\n               'O=/data/output.bam',\n               'I=/data/input.bam']\n    docker_parameters = ['--rm',\n                         '--log-driver', 'none',\n                         '-e', 'JAVA_OPTIONS=-Djava.io.tmpdir=/data/ -Xmx{}'.format(job.memory),\n                         '-v', '{}:/data'.format(work_dir)]\n    if sort_by_name:\n        command.append('SO=queryname')\n    else:\n        command.append('SO=coordinate')\n    start_time = time.time()\n    dockerCall(job=job, workDir=work_dir,\n               parameters=command,\n               tool='quay.io/ucsc_cgl/picardtools:1.95--dd5ac549b95eb3e5d166a5e310417ef13651994e',\n               dockerParameters=docker_parameters)\n    end_time = time.time()\n    _log_runtime(job, start_time, end_time, \"Picard SortSam\")\n    return job.fileStore.writeGlobalFile(os.path.join(work_dir, 'output.bam'))"
    },
    {
        "code": "def crash_handler_lite(etype, evalue, tb):\n    traceback.print_exception(etype, evalue, tb)\n    from IPython.core.interactiveshell import InteractiveShell\n    if InteractiveShell.initialized():\n        config = \"%config \"\n    else:\n        config = \"c.\"\n    print >> sys.stderr, _lite_message_template.format(email=author_email, config=config)"
    },
    {
        "code": "def rule(cls, rulename=None, erase=False):\n    if not hasattr(cls, '_rules'):\n        raise TypeError(\n            \"%s didn't seems to be a BasicParser subsclasse\" % cls.__name__)\n    class_hook_list = cls._hooks\n    class_rule_list = cls._rules\n    def wrapper(f):\n        nonlocal rulename\n        add_method(cls)(f)\n        if rulename is None:\n            rulename = f.__name__\n        if not erase and (rulename in class_hook_list or rulename in class_rule_list):\n            raise TypeError(\"%s is already define has rule or hook\" % rulename)\n        if '.' not in rulename:\n            rulename = cls.__module__ + '.' + cls.__name__ + '.' + rulename\n        set_one(class_rule_list, rulename, f)\n        return f\n    return wrapper"
    },
    {
        "code": "def set_request_header(self, name, value):\n        _name = BSTR(name)\n        _value = BSTR(value)\n        _WinHttpRequest._SetRequestHeader(self, _name, _value)"
    },
    {
        "code": "def source_expand(self, source):\n    result = []\n    if not isinstance(source, list):\n      source = [source]\n    for src in source:\n      tmp = self.opt.recursive\n      self.opt.recursive = False\n      result += [f['name'] for f in self.s3walk(src, True)]\n      self.opt.recursive = tmp\n    if (len(result) == 0) and (not self.opt.ignore_empty_source):\n      fail(\"[Runtime Failure] Source doesn't exist.\")\n    return result"
    },
    {
        "code": "def new_frontend_master(self):\n        ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST\n        kernel_manager = self.kernel_manager_class(\n                                ip=ip,\n                                connection_file=self._new_connection_file(),\n                                config=self.config,\n        )\n        kwargs = dict()\n        kwargs['extra_arguments'] = self.kernel_argv\n        kernel_manager.start_kernel(**kwargs)\n        kernel_manager.start_channels()\n        widget = self.widget_factory(config=self.config,\n                                   local_kernel=True)\n        self.init_colors(widget)\n        widget.kernel_manager = kernel_manager\n        widget._existing = False\n        widget._may_close = True\n        widget._confirm_exit = self.confirm_exit\n        return widget"
    },
    {
        "code": "def valid(self):\n        if self.expiration_time:\n            return self.expiration_time > int(time.time())\n        else:\n            return True"
    },
    {
        "code": "def add_new_heart_handler(self, handler):\n        self.log.debug(\"heartbeat::new_heart_handler: %s\", handler)\n        self._new_handlers.add(handler)"
    },
    {
        "code": "def get_ordered_list_type(meta_data, numId, ilvl):\n    numbering_dict = meta_data.numbering_dict\n    if numId not in numbering_dict:\n        return DEFAULT_LIST_NUMBERING_STYLE\n    if ilvl not in numbering_dict[numId]:\n        return DEFAULT_LIST_NUMBERING_STYLE\n    return meta_data.numbering_dict[numId][ilvl]"
    },
    {
        "code": "def configure_inline_support(shell, backend, user_ns=None):\n    try:\n        from IPython.zmq.pylab.backend_inline import InlineBackend\n    except ImportError:\n        return\n    user_ns = shell.user_ns if user_ns is None else user_ns\n    cfg = InlineBackend.instance(config=shell.config)\n    cfg.shell = shell\n    if cfg not in shell.configurables:\n        shell.configurables.append(cfg)\n    if backend == backends['inline']:\n        from IPython.zmq.pylab.backend_inline import flush_figures\n        from matplotlib import pyplot\n        shell.register_post_execute(flush_figures)\n        pyplot.rcParams.update(cfg.rc)\n        user_ns['figsize'] = pyplot.figsize = figsize\n    fmt = cfg.figure_format\n    select_figure_format(shell, fmt)\n    from IPython.core.display import display\n    user_ns['display'] = display\n    user_ns['getfigs'] = getfigs"
    },
    {
        "code": "def decode_bytecode(bytecode):\n    bytecode_wnd = memoryview(bytecode)\n    while bytecode_wnd:\n        opcode_id = byte2int(bytecode_wnd[0])\n        opcode = OPCODE_MAP[opcode_id]\n        if opcode.imm_struct is not None:\n            offs, imm, _ = opcode.imm_struct.from_raw(None, bytecode_wnd[1:])\n        else:\n            imm = None\n            offs = 0\n        insn_len = 1 + offs\n        yield Instruction(opcode, imm, insn_len)\n        bytecode_wnd = bytecode_wnd[insn_len:]"
    },
    {
        "code": "def __complete_interns(\n        self, value: str, include_private_vars: bool = True\n    ) -> Iterable[str]:\n        if include_private_vars:\n            is_match = Namespace.__completion_matcher(value)\n        else:\n            _is_match = Namespace.__completion_matcher(value)\n            def is_match(entry: Tuple[sym.Symbol, Var]) -> bool:\n                return _is_match(entry) and not entry[1].is_private\n        return map(\n            lambda entry: f\"{entry[0].name}\",\n            filter(is_match, [(s, v) for s, v in self.interns]),\n        )"
    },
    {
        "code": "def configure(self, options, config):\n        Plugin.configure(self, options, config)\n        self.config = config\n        if self.enabled:\n            self.stats = {'errors': 0,\n                          'failures': 0,\n                          'passes': 0,\n                          'skipped': 0\n                          }\n            self.errorlist = []\n            self.error_report_file = codecs.open(options.xunit_file, 'w',\n                                                 self.encoding, 'replace')"
    },
    {
        "code": "def renew_lock(self):\n        if self._queue_name:\n            self.service_bus_service.renew_lock_queue_message(\n                self._queue_name,\n                self.broker_properties['SequenceNumber'],\n                self.broker_properties['LockToken'])\n        elif self._topic_name and self._subscription_name:\n            self.service_bus_service.renew_lock_subscription_message(\n                self._topic_name,\n                self._subscription_name,\n                self.broker_properties['SequenceNumber'],\n                self.broker_properties['LockToken'])\n        else:\n            raise AzureServiceBusPeekLockError(_ERROR_MESSAGE_NOT_PEEK_LOCKED_ON_RENEW_LOCK)"
    },
    {
        "code": "def call(self, inputs):\n    net = self.encoder_net(tf.cast(inputs, tf.float32))\n    return ed.MultivariateNormalDiag(\n        loc=net[..., :self.latent_size],\n        scale_diag=tf.nn.softplus(net[..., self.latent_size:]),\n        name=\"latent_code_posterior\")"
    },
    {
        "code": "def kvlayer_key_to_stream_id(k):\n    abs_url_hash, epoch_ticks = k\n    return '{0}-{1}'.format(epoch_ticks,\n                            base64.b16encode(abs_url_hash).lower())"
    },
    {
        "code": "def update_binary_annotations(self, extra_annotations):\n        if not self.logging_context:\n            self.binary_annotations.update(extra_annotations)\n        else:\n            self.logging_context.tags.update(extra_annotations)"
    },
    {
        "code": "def status(self,verbose=0):\n        self._update_status()\n        self._group_report(self.running,'Running')\n        self._group_report(self.completed,'Completed')\n        self._group_report(self.dead,'Dead')\n        self._comp_report[:] = []\n        self._dead_report[:] = []"
    },
    {
        "code": "def visit_table(self, layout):\n        table_content = self.get_table_content(layout)\n        cols_width = [0] * len(table_content[0])\n        for row in table_content:\n            for index, col in enumerate(row):\n                cols_width[index] = max(cols_width[index], len(col))\n        self.default_table(layout, table_content, cols_width)\n        self.writeln()"
    },
    {
        "code": "def no_exp(number):\n    r\n    mant, exp = to_scientific_tuple(number)\n    if not exp:\n        return str(number)\n    floating_mant = \".\" in mant\n    mant = mant.replace(\".\", \"\")\n    if exp < 0:\n        return \"0.\" + \"0\" * (-exp - 1) + mant\n    if not floating_mant:\n        return mant + \"0\" * exp + (\".0\" if isinstance(number, float) else \"\")\n    lfpart = len(mant) - 1\n    if lfpart < exp:\n        return (mant + \"0\" * (exp - lfpart)).rstrip(\".\")\n    return mant"
    },
    {
        "code": "def url_query_params(url):\n    return dict(urlparse.parse_qsl(urlparse.urlparse(url).query, True))"
    },
    {
        "code": "def path_dispatch_old_new(mname, returns_model):\n    def _wrapper(self, old_path, new_path, *args, **kwargs):\n        old_prefix, old_mgr, old_mgr_path = _resolve_path(\n            old_path, self.managers\n        )\n        new_prefix, new_mgr, new_mgr_path = _resolve_path(\n            new_path, self.managers,\n        )\n        if old_mgr is not new_mgr:\n            raise HTTPError(\n                400,\n                \"Can't move files between backends ({old} -> {new})\".format(\n                    old=old_path,\n                    new=new_path,\n                )\n            )\n        assert new_prefix == old_prefix\n        result = getattr(new_mgr, mname)(\n            old_mgr_path,\n            new_mgr_path,\n            *args,\n            **kwargs\n        )\n        if returns_model and new_prefix:\n            return _apply_prefix(new_prefix, result)\n        else:\n            return result\n    return _wrapper"
    },
    {
        "code": "def get_admins(self, account_id, params={}):\n        url = ADMINS_API.format(account_id)\n        admins = []\n        for data in self._get_paged_resource(url, params=params):\n            admins.append(CanvasAdmin(data=data))\n        return admins"
    },
    {
        "code": "def set_feature_transform(self, mode='polynomial', degree=1):\n        if self.status != 'load_train_data':\n            print(\"Please load train data first.\")\n            return self.train_X\n        self.feature_transform_mode = mode\n        self.feature_transform_degree = degree\n        self.train_X = self.train_X[:, 1:]\n        self.train_X = utility.DatasetLoader.feature_transform(\n            self.train_X,\n            self.feature_transform_mode,\n            self.feature_transform_degree\n        )\n        return self.train_X"
    },
    {
        "code": "def _wanmen_get_title_by_json_topic_part(json_content, tIndex, pIndex):\n    return '_'.join([json_content[0]['name'],\n                    json_content[0]['Topics'][tIndex]['name'],\n                    json_content[0]['Topics'][tIndex]['Parts'][pIndex]['name']])"
    },
    {
        "code": "def fallback_to_default_project_id(func):\n        @functools.wraps(func)\n        def inner_wrapper(self, *args, **kwargs):\n            if len(args) > 0:\n                raise AirflowException(\n                    \"You must use keyword arguments in this methods rather than\"\n                    \" positional\")\n            if 'project_id' in kwargs:\n                kwargs['project_id'] = self._get_project_id(kwargs['project_id'])\n            else:\n                kwargs['project_id'] = self._get_project_id(None)\n            if not kwargs['project_id']:\n                raise AirflowException(\"The project id must be passed either as \"\n                                       \"keyword project_id parameter or as project_id extra \"\n                                       \"in GCP connection definition. Both are not set!\")\n            return func(self, *args, **kwargs)\n        return inner_wrapper"
    },
    {
        "code": "def get_model_class(settings_entry_name):\n    app_name, model_name = get_app_n_model(settings_entry_name)\n    try:\n        model = apps_get_model(app_name, model_name)\n    except (LookupError, ValueError):\n        model = None\n    if model is None:\n        raise ImproperlyConfigured(\n            '`SITETREE_%s` refers to model `%s` that has not been installed.' % (settings_entry_name, model_name))\n    return model"
    },
    {
        "code": "def draw(self):\n        self.screen.border(0)\n        if self.title is not None:\n            self.screen.addstr(2, 2, self.title, curses.A_STANDOUT)\n        if self.subtitle is not None:\n            self.screen.addstr(4, 2, self.subtitle, curses.A_BOLD)\n        for index, item in enumerate(self.items):\n            if self.current_option == index:\n                text_style = self.highlight\n            else:\n                text_style = self.normal\n            self.screen.addstr(5 + index, 4, item.show(index), text_style)\n        screen_rows, screen_cols = CursesMenu.stdscr.getmaxyx()\n        top_row = 0\n        if 6 + len(self.items) > screen_rows:\n            if screen_rows + self.current_option < 6 + len(self.items):\n                top_row = self.current_option\n            else:\n                top_row = 6 + len(self.items) - screen_rows\n        self.screen.refresh(top_row, 0, 0, 0, screen_rows - 1, screen_cols - 1)"
    },
    {
        "code": "def svg_to_image(string, size=None):\n    if isinstance(string, unicode):\n        string = string.encode('utf-8')\n    renderer = QtSvg.QSvgRenderer(QtCore.QByteArray(string))\n    if not renderer.isValid():\n        raise ValueError('Invalid SVG data.')\n    if size is None:\n        size = renderer.defaultSize()\n    image = QtGui.QImage(size, QtGui.QImage.Format_ARGB32)\n    painter = QtGui.QPainter(image)\n    renderer.render(painter)\n    return image"
    },
    {
        "code": "def token_indent(self, idx):\n        line_indent = self.line_indent(idx)\n        return line_indent + \" \" * (self.start_col(idx) - len(line_indent))"
    },
    {
        "code": "def close(self):\n        self.flush()\n        setattr(sys, self.channel, self.ostream)\n        self.file.close()\n        self._closed = True"
    },
    {
        "code": "def info(self):\n        for key, val in self.header.items():\n            if key == b'src_raj':\n                val = val.to_string(unit=u.hour, sep=':')\n            if key == b'src_dej':\n                val = val.to_string(unit=u.deg, sep=':')\n            if key == b'tsamp':\n                val *= u.second\n            if key in ('foff', 'fch1'):\n                val *= u.MHz\n            if key == b'tstart':\n                print(\"%16s : %32s\" % (\"tstart (ISOT)\", Time(val, format='mjd').isot))\n                key = \"tstart (MJD)\"\n            print(\"%16s : %32s\" % (key, val))\n        print(\"\\n%16s : %32s\" % (\"Num ints in file\", self.n_ints_in_file))\n        print(\"%16s : %32s\" % (\"Data shape\", self.data.shape))\n        print(\"%16s : %32s\" % (\"Start freq (MHz)\", self.freqs[0]))\n        print(\"%16s : %32s\" % (\"Stop freq (MHz)\", self.freqs[-1]))"
    },
    {
        "code": "def fromRaw(cls, skype=None, raw={}):\n        return cls(skype, raw, **cls.rawToFields(raw))"
    },
    {
        "code": "def inherit_from_std_ex(node: astroid.node_classes.NodeNG) -> bool:\n    ancestors = node.ancestors() if hasattr(node, \"ancestors\") else []\n    for ancestor in itertools.chain([node], ancestors):\n        if (\n            ancestor.name in (\"Exception\", \"BaseException\")\n            and ancestor.root().name == EXCEPTIONS_MODULE\n        ):\n            return True\n    return False"
    },
    {
        "code": "def findStationCodesByCity(city_name, token):\n    req = requests.get(\n        API_ENDPOINT_SEARCH,\n        params={\n            'token': token,\n            'keyword': city_name\n        })\n    if req.status_code == 200 and req.json()[\"status\"] == \"ok\":\n        return [result[\"uid\"] for result in req.json()[\"data\"]]\n    else:\n        return []"
    },
    {
        "code": "def v2_playbook_on_task_start(self, task, **kwargs):\n        self.last_task_name = task.get_name()\n        self.printed_last_task = False"
    },
    {
        "code": "def _register_stements(self, statements: List[\"HdlStatement\"],\n                           target: List[\"HdlStatement\"]):\n        for stm in flatten(statements):\n            assert stm.parentStm is None, stm\n            stm._set_parent_stm(self)\n            target.append(stm)"
    },
    {
        "code": "def _query_cassandra(self):\n        self.hook = CassandraHook(cassandra_conn_id=self.cassandra_conn_id)\n        session = self.hook.get_conn()\n        cursor = session.execute(self.cql)\n        return cursor"
    },
    {
        "code": "def request_tokens(self):\n        url = 'https://api.ecobee.com/token'\n        params = {'grant_type': 'ecobeePin', 'code': self.authorization_code,\n                  'client_id': self.api_key}\n        try:\n            request = requests.post(url, params=params)\n        except RequestException:\n            logger.warn(\"Error connecting to Ecobee.  Possible connectivity outage.\"\n                        \"Could not request token.\")\n            return\n        if request.status_code == requests.codes.ok:\n            self.access_token = request.json()['access_token']\n            self.refresh_token = request.json()['refresh_token']\n            self.write_tokens_to_file()\n            self.pin = None\n        else:\n            logger.warn('Error while requesting tokens from ecobee.com.'\n                  ' Status code: ' + str(request.status_code))\n            return"
    },
    {
        "code": "def cancel_task(self, task_id):\n        self.registry.remove(task_id)\n        self._scheduler.cancel_job_task(task_id)\n        logger.info(\"Task %s canceled\", task_id)"
    },
    {
        "code": "def _superop_to_choi(data, input_dim, output_dim):\n    shape = (output_dim, output_dim, input_dim, input_dim)\n    return _reshuffle(data, shape)"
    },
    {
        "code": "def status(institute_id, case_name):\n    institute_obj, case_obj = institute_and_case(store, institute_id, case_name)\n    user_obj = store.user(current_user.email)\n    status = request.form.get('status', case_obj['status'])\n    link = url_for('.case', institute_id=institute_id, case_name=case_name)\n    if status == 'archive':\n        store.archive_case(institute_obj, case_obj, user_obj, status, link)\n    else:\n        store.update_status(institute_obj, case_obj, user_obj, status, link)\n    return redirect(request.referrer)"
    },
    {
        "code": "def update_database(self, instance_id, database_id, ddl_statements,\n                        project_id=None,\n                        operation_id=None):\n        instance = self._get_client(project_id=project_id).instance(\n            instance_id=instance_id)\n        if not instance.exists():\n            raise AirflowException(\"The instance {} does not exist in project {} !\".\n                                   format(instance_id, project_id))\n        database = instance.database(database_id=database_id)\n        try:\n            operation = database.update_ddl(\n                ddl_statements=ddl_statements, operation_id=operation_id)\n            if operation:\n                result = operation.result()\n                self.log.info(result)\n            return\n        except AlreadyExists as e:\n            if e.code == 409 and operation_id in e.message:\n                self.log.info(\"Replayed update_ddl message - the operation id %s \"\n                              \"was already done before.\", operation_id)\n                return\n        except GoogleAPICallError as e:\n            self.log.error('An error occurred: %s. Exiting.', e.message)\n            raise e"
    },
    {
        "code": "def name(self):\n        name = self._platform_impl.get_process_name()\n        if os.name == 'posix':\n            try:\n                cmdline = self.cmdline\n            except AccessDenied:\n                pass\n            else:\n                if cmdline:\n                    extended_name = os.path.basename(cmdline[0])\n                    if extended_name.startswith(name):\n                        name = extended_name\n        self._platform_impl._process_name = name\n        return name"
    },
    {
        "code": "def create_group(self, group):\n        self._valid_group_id(group.id)\n        body = {\"data\": group.json_data()}\n        url = \"{}/group/{}\".format(self.API, group.name)\n        data = self._put_resource(url, headers={}, body=body)\n        return self._group_from_json(data.get(\"data\"))"
    },
    {
        "code": "def _minimal_export_traces(self, outdir=None, analytes=None,\n                               samples=None, subset='All_Analyses'):\n        if analytes is None:\n            analytes = self.analytes\n        elif isinstance(analytes, str):\n            analytes = [analytes]\n        if samples is not None:\n            subset = self.make_subset(samples)\n        samples = self._get_samples(subset)\n        focus_stage = 'rawdata'\n        if not os.path.isdir(outdir):\n            os.mkdir(outdir)\n        for s in samples:\n            d = self.data[s].data[focus_stage]\n            out = Bunch()\n            for a in analytes:\n                out[a] = d[a]\n            out = pd.DataFrame(out, index=self.data[s].Time)\n            out.index.name = 'Time'\n            d = dateutil.parser.parse(self.data[s].meta['date'])\n            header = ['\n                      (time.strftime('%Y:%m:%d %H:%M:%S')),\n                      \"\n                      '\n                      '\n                      '\n                      '\n            header = '\\n'.join(header) + '\\n'\n            csv = out.to_csv()\n            with open('%s/%s.csv' % (outdir, s), 'w') as f:\n                f.write(header)\n                f.write(csv)\n        return"
    },
    {
        "code": "def as_recarray(self):\n        dtype = [(k,v.dtype) for k,v in self.__dict__.iteritems()]\n        R = numpy.recarray(len(self.__dict__[k]),dtype=dtype)\n        for key in self.__dict__:\n            R[key] = self.__dict__[key]\n        return R"
    },
    {
        "code": "def unregister(self, mimetype, processor):\n        if mimetype in self and processor in self[mimetype]:\n            self[mimetype].remove(processor)"
    },
    {
        "code": "def _write_iop_to_file(self, iop, file_name):\n        lg.info('Writing :: ' + file_name)\n        f = open(file_name, 'w')\n        for i in scipy.nditer(iop):\n            f.write(str(i) + '\\n')"
    },
    {
        "code": "async def get_tracks(self, *, limit: Optional[int] = 20, offset: Optional[int] = 0) -> List[Track]:\n        data = await self.__client.http.album_tracks(self.id, limit=limit, offset=offset)\n        return list(Track(self.__client, item) for item in data['items'])"
    },
    {
        "code": "def get_ammo_generator(self):\n        af_readers = {\n            'phantom': missile.AmmoFileReader,\n            'slowlog': missile.SlowLogReader,\n            'line': missile.LineReader,\n            'uri': missile.UriReader,\n            'uripost': missile.UriPostReader,\n            'access': missile.AccessLogReader,\n            'caseline': missile.CaseLineReader,\n        }\n        if self.uris and self.ammo_file:\n            raise StepperConfigurationError(\n                'Both uris and ammo file specified. You must specify only one of them'\n            )\n        elif self.uris:\n            ammo_gen = missile.UriStyleGenerator(\n                self.uris, self.headers, http_ver=self.http_ver)\n        elif self.ammo_file:\n            if self.ammo_type in af_readers:\n                if self.ammo_type == 'phantom':\n                    opener = resource.get_opener(self.ammo_file)\n                    with opener(self.use_cache) as ammo:\n                        try:\n                            if not ammo.next()[0].isdigit():\n                                self.ammo_type = 'uri'\n                                self.log.info(\n                                    \"Setting ammo_type 'uri' because ammo is not started with digit and you did not specify ammo format\"\n                                )\n                            else:\n                                self.log.info(\n                                    \"Default ammo type ('phantom') used, use 'phantom.ammo_type' option to override it\"\n                                )\n                        except StopIteration:\n                            self.log.exception(\n                                \"Couldn't read first line of ammo file\")\n                            raise AmmoFileError(\n                                \"Couldn't read first line of ammo file\")\n            else:\n                raise NotImplementedError(\n                    'No such ammo type implemented: \"%s\"' % self.ammo_type)\n            ammo_gen = af_readers[self.ammo_type](\n                self.ammo_file, headers=self.headers, http_ver=self.http_ver, use_cache=self.use_cache)\n        else:\n            raise StepperConfigurationError(\n                'Ammo not found. Specify uris or ammo file')\n        self.log.info(\"Using %s ammo reader\" % type(ammo_gen).__name__)\n        return ammo_gen"
    },
    {
        "code": "def check_rdd_dtype(rdd, expected_dtype):\n    if not isinstance(rdd, BlockRDD):\n        raise TypeError(\"Expected {0} for parameter rdd, got {1}.\"\n                        .format(BlockRDD, type(rdd)))\n    if isinstance(rdd, DictRDD):\n        if not isinstance(expected_dtype, dict):\n            raise TypeError('Expected {0} for parameter '\n                            'expected_dtype, got {1}.'\n                            .format(dict, type(expected_dtype)))\n        accept = True\n        types = dict(list(zip(rdd.columns, rdd.dtype)))\n        for key, values in expected_dtype.items():\n            if not isinstance(values, (tuple, list)):\n                values = [values]\n            accept = accept and types[key] in values\n        return accept\n    if not isinstance(expected_dtype, (tuple, list)):\n        expected_dtype = [expected_dtype]\n    return rdd.dtype in expected_dtype"
    },
    {
        "code": "def entropy(state):\n    rho = np.array(state)\n    if rho.ndim == 1:\n        return 0\n    evals = np.maximum(np.linalg.eigvalsh(state), 0.)\n    return shannon_entropy(evals, base=np.e)"
    },
    {
        "code": "def python_matches(self,text):\n        if \".\" in text:\n            try:\n                matches = self.attr_matches(text)\n                if text.endswith('.') and self.omit__names:\n                    if self.omit__names == 1:\n                        no__name = (lambda txt:\n                                    re.match(r'.*\\.__.*?__',txt) is None)\n                    else:\n                        no__name = (lambda txt:\n                                    re.match(r'.*\\._.*?',txt) is None)\n                    matches = filter(no__name, matches)\n            except NameError:\n                matches = []\n        else:\n            matches = self.global_matches(text)\n        return matches"
    },
    {
        "code": "def subwave(wave, dep_name=None, indep_min=None, indep_max=None, indep_step=None):\n    r\n    ret = copy.copy(wave)\n    if dep_name is not None:\n        ret.dep_name = dep_name\n    _bound_waveform(ret, indep_min, indep_max)\n    pexdoc.addai(\"indep_step\", bool((indep_step is not None) and (indep_step <= 0)))\n    exmsg = \"Argument `indep_step` is greater than independent vector range\"\n    cond = bool(\n        (indep_step is not None)\n        and (indep_step > ret._indep_vector[-1] - ret._indep_vector[0])\n    )\n    pexdoc.addex(RuntimeError, exmsg, cond)\n    if indep_step:\n        indep_vector = _barange(indep_min, indep_max, indep_step)\n        dep_vector = _interp_dep_vector(ret, indep_vector)\n        ret._set_indep_vector(indep_vector, check=False)\n        ret._set_dep_vector(dep_vector, check=False)\n    return ret"
    },
    {
        "code": "def init_transformers(self):\n        self._transformers = []\n        for transformer_cls in _default_transformers:\n            transformer_cls(\n                shell=self.shell, prefilter_manager=self, config=self.config\n            )"
    },
    {
        "code": "def _mode(self):\n    return (self.mean_direction +\n            tf.zeros_like(self.concentration)[..., tf.newaxis])"
    },
    {
        "code": "def _prepare_args_with_initial_vertex(objective_function,\n                                      initial_vertex,\n                                      step_sizes,\n                                      objective_at_initial_vertex,\n                                      batch_evaluate_objective):\n  dim = tf.size(input=initial_vertex)\n  num_vertices = dim + 1\n  unit_vectors_along_axes = tf.reshape(\n      tf.eye(dim, dim, dtype=initial_vertex.dtype.base_dtype),\n      tf.concat([[dim], tf.shape(input=initial_vertex)], axis=0))\n  simplex_face = initial_vertex + step_sizes * unit_vectors_along_axes\n  simplex = tf.concat([tf.expand_dims(initial_vertex, axis=0),\n                       simplex_face], axis=0)\n  num_evaluations = 0\n  if objective_at_initial_vertex is None:\n    objective_at_initial_vertex = objective_function(initial_vertex)\n    num_evaluations += 1\n  objective_at_simplex_face, num_evals = _evaluate_objective_multiple(\n      objective_function, simplex_face, batch_evaluate_objective)\n  num_evaluations += num_evals\n  objective_at_simplex = tf.concat(\n      [\n          tf.expand_dims(objective_at_initial_vertex, axis=0),\n          objective_at_simplex_face\n      ], axis=0)\n  return (dim,\n          num_vertices,\n          simplex,\n          objective_at_simplex,\n          num_evaluations)"
    },
    {
        "code": "def convertBits(self, sigOrVal, toType):\n    if isinstance(sigOrVal, Value):\n        return convertBits__val(self, sigOrVal, toType)\n    elif isinstance(toType, HBool):\n        if self.bit_length() == 1:\n            v = 0 if sigOrVal._dtype.negated else 1\n            return sigOrVal._eq(self.getValueCls().fromPy(v, self))\n    elif isinstance(toType, Bits):\n        if self.bit_length() == toType.bit_length():\n            return sigOrVal._convSign(toType.signed)\n    elif toType == INT:\n        return Operator.withRes(AllOps.BitsToInt, [sigOrVal], toType)\n    return default_auto_cast_fn(self, sigOrVal, toType)"
    },
    {
        "code": "def from_symbol(cls, symbol):\n        if symbol.lower() == symbol:\n            return cls(PIECE_SYMBOLS.index(symbol), WHITE)\n        else:\n            return cls(PIECE_SYMBOLS.index(symbol.lower()), BLACK)"
    },
    {
        "code": "def pauli_group(number_of_qubits, case='weight'):\n    if number_of_qubits < 5:\n        temp_set = []\n        if case == 'weight':\n            tmp = pauli_group(number_of_qubits, case='tensor')\n            return sorted(tmp, key=lambda x: -np.count_nonzero(\n                np.array(x.to_label(), 'c') == b'I'))\n        elif case == 'tensor':\n            for k in range(4 ** number_of_qubits):\n                z = np.zeros(number_of_qubits, dtype=np.bool)\n                x = np.zeros(number_of_qubits, dtype=np.bool)\n                for j in range(number_of_qubits):\n                    element = (k // (4 ** j)) % 4\n                    if element == 1:\n                        x[j] = True\n                    elif element == 2:\n                        z[j] = True\n                        x[j] = True\n                    elif element == 3:\n                        z[j] = True\n                temp_set.append(Pauli(z, x))\n            return temp_set\n        else:\n            raise QiskitError(\"Only support 'weight' or 'tensor' cases \"\n                              \"but you have {}.\".format(case))\n    raise QiskitError(\"Only support number of qubits is less than 5\")"
    },
    {
        "code": "def _validate(self, qobj):\n        n_qubits = qobj.config.n_qubits\n        max_qubits = self.configuration().n_qubits\n        if n_qubits > max_qubits:\n            raise BasicAerError('Number of qubits {} '.format(n_qubits) +\n                                'is greater than maximum ({}) '.format(max_qubits) +\n                                'for \"{}\".'.format(self.name()))\n        for experiment in qobj.experiments:\n            name = experiment.header.name\n            if experiment.config.memory_slots == 0:\n                logger.warning('No classical registers in circuit \"%s\", '\n                               'counts will be empty.', name)\n            elif 'measure' not in [op.name for op in experiment.instructions]:\n                logger.warning('No measurements in circuit \"%s\", '\n                               'classical register will remain all zeros.', name)"
    },
    {
        "code": "def classification(self, classification):\n        allowed_values = [\"Public Limited Indian Non-Government Company\", \"Private Limited Indian Non-Government Company\", \"One Person Company\", \"Private Limited Foreign Company Incorporated in India\", \"Public Limited Foreign Company Incorporated in India\", \"Union Government Company\", \"State Government Company\", \"Guarantee & Association Public\", \"Guarantee & Association Private\", \"Not For Profit Company\", \"Unlimited Liabilities Public\", \"Unlimited Liabilities Private\", \"Undefined\"]\n        if classification not in allowed_values:\n            raise ValueError(\n                \"Invalid value for `classification`, must be one of {0}\"\n                .format(allowed_values)\n            )\n        self._classification = classification"
    },
    {
        "code": "def val_where(cond, tval, fval):\n  if isinstance(tval, tf.Tensor):\n    return tf.where(cond, tval, fval)\n  elif isinstance(tval, tuple):\n    cls = type(tval)\n    return cls(*(val_where(cond, t, f) for t, f in zip(tval, fval)))\n  else:\n    raise Exception(TypeError)"
    },
    {
        "code": "def get_embedding_levels(text, storage, upper_is_rtl=False, debug=False):\n    prev_surrogate = False\n    base_level = storage['base_level']\n    for _ch in text:\n        if _IS_UCS2 and (_SURROGATE_MIN <= ord(_ch) <= _SURROGATE_MAX):\n            prev_surrogate = _ch\n            continue\n        elif prev_surrogate:\n            _ch = prev_surrogate + _ch\n            prev_surrogate = False\n        if upper_is_rtl and _ch.isupper():\n            bidi_type = 'R'\n        else:\n            bidi_type = bidirectional(_ch)\n        storage['chars'].append({\n            'ch': _ch,\n            'level': base_level,\n            'type': bidi_type,\n            'orig': bidi_type\n        })\n    if debug:\n        debug_storage(storage, base_info=True)"
    },
    {
        "code": "def load(self):\n        self._check_open()\n        try:\n            data = json.load(self.file, **self.load_args)\n        except ValueError:\n            data = {}\n        if not isinstance(data, dict):\n            raise ValueError('Root JSON type must be dictionary')\n        self.clear()\n        self.update(data)"
    },
    {
        "code": "def calc(pvalues, lamb):\n    m = len(pvalues)\n    pi0 = (pvalues > lamb).sum() / ((1 - lamb)*m)\n    pFDR = np.ones(m)\n    print(\"pFDR    y        Pr     fastPow\")\n    for i in range(m):\n        y = pvalues[i]\n        Pr = max(1, m - i) / float(m)\n        pFDR[i] = (pi0 * y) / (Pr * (1 - math.pow(1-y, m)))\n        print(i, pFDR[i], y, Pr, 1.0 - math.pow(1-y, m))\n    num_null = pi0*m\n    num_alt = m - num_null\n    num_negs = np.array(range(m))\n    num_pos = m - num_negs\n    pp = num_pos / float(m)\n    qvalues = np.ones(m)\n    qvalues[0] = pFDR[0]\n    for i in range(m-1):\n        qvalues[i+1] = min(qvalues[i], pFDR[i+1])\n    sens = ((1.0 - qvalues) * num_pos) / num_alt\n    sens[sens > 1.0] = 1.0\n    df = pd.DataFrame(dict(\n        pvalue=pvalues,\n        qvalue=qvalues,\n        FDR=pFDR,\n        percentile_positive=pp,\n        sens=sens\n    ))\n    df[\"svalue\"] = df.sens[::-1].cummax()[::-1]\n    return df, num_null, m"
    },
    {
        "code": "def series(collection, method, prints = 15, *args, **kwargs):\n    if 'verbose' in kwargs.keys():\n        verbose = kwargs['verbose']\n    else:\n        verbose = True\n    results = []\n    timer = turntable.utils.Timer(nLoops=len(collection), numPrints=prints, verbose=verbose)\n    for subject in collection:\n        results.append(method(subject, *args, **kwargs))\n        timer.loop()\n    timer.fin()\n    return results"
    },
    {
        "code": "def getlist(self, section, option):\n        value_list = self.get(section, option)\n        values = []\n        for value_line in value_list.split('\\n'):\n            for value in value_line.split(','):\n                value = value.strip()\n                if value:\n                    values.append(value)\n        return values"
    },
    {
        "code": "def glob(self, pattern):\n        cls = self.__class__\n        return [cls(s) for s in glob.glob(unicode(self / pattern))]"
    },
    {
        "code": "def export_html(html, filename, image_tag = None, inline = True):\n    if image_tag is None:\n        image_tag = default_image_tag\n    else:\n        image_tag = ensure_utf8(image_tag)\n    if inline:\n        path = None\n    else:\n        root,ext = os.path.splitext(filename)\n        path = root + \"_files\"\n        if os.path.isfile(path):\n            raise OSError(\"%s exists, but is not a directory.\" % path)\n    with open(filename, 'w') as f:\n        html = fix_html(html)\n        f.write(IMG_RE.sub(lambda x: image_tag(x, path = path, format = \"png\"),\n                           html))"
    },
    {
        "code": "def export(self, cert, key, type=FILETYPE_PEM, days=100,\n               digest=_UNSPECIFIED):\n        if not isinstance(cert, X509):\n            raise TypeError(\"cert must be an X509 instance\")\n        if not isinstance(key, PKey):\n            raise TypeError(\"key must be a PKey instance\")\n        if not isinstance(type, int):\n            raise TypeError(\"type must be an integer\")\n        if digest is _UNSPECIFIED:\n            raise TypeError(\"digest must be provided\")\n        digest_obj = _lib.EVP_get_digestbyname(digest)\n        if digest_obj == _ffi.NULL:\n            raise ValueError(\"No such digest method\")\n        bio = _lib.BIO_new(_lib.BIO_s_mem())\n        _openssl_assert(bio != _ffi.NULL)\n        sometime = _lib.ASN1_TIME_new()\n        _openssl_assert(sometime != _ffi.NULL)\n        _lib.X509_gmtime_adj(sometime, 0)\n        _lib.X509_CRL_set_lastUpdate(self._crl, sometime)\n        _lib.X509_gmtime_adj(sometime, days * 24 * 60 * 60)\n        _lib.X509_CRL_set_nextUpdate(self._crl, sometime)\n        _lib.X509_CRL_set_issuer_name(\n            self._crl, _lib.X509_get_subject_name(cert._x509)\n        )\n        sign_result = _lib.X509_CRL_sign(self._crl, key._pkey, digest_obj)\n        if not sign_result:\n            _raise_current_error()\n        return dump_crl(type, self)"
    },
    {
        "code": "def parse_text(text):\n    assert isinstance(text, _str_type), \"`text` parameter should be a string, got %r\" % type(text)\n    gen = iter(text.splitlines(True))\n    readline = gen.next if hasattr(gen, \"next\") else gen.__next__\n    return Code(_tokenize(readline))"
    },
    {
        "code": "def parsed_forensic_reports_to_csv(reports):\n    fields = [\"feedback_type\", \"user_agent\", \"version\", \"original_envelope_id\",\n              \"original_mail_from\", \"original_rcpt_to\", \"arrival_date\",\n              \"arrival_date_utc\", \"subject\", \"message_id\",\n              \"authentication_results\", \"dkim_domain\", \"source_ip_address\",\n              \"source_country\", \"source_reverse_dns\", \"source_base_domain\",\n              \"delivery_result\", \"auth_failure\", \"reported_domain\",\n              \"authentication_mechanisms\", \"sample_headers_only\"]\n    if type(reports) == OrderedDict:\n        reports = [reports]\n    csv_file = StringIO()\n    csv_writer = DictWriter(csv_file, fieldnames=fields)\n    csv_writer.writeheader()\n    for report in reports:\n        row = report.copy()\n        row[\"source_ip_address\"] = report[\"source\"][\"ip_address\"]\n        row[\"source_reverse_dns\"] = report[\"source\"][\"reverse_dns\"]\n        row[\"source_base_domain\"] = report[\"source\"][\"base_domain\"]\n        row[\"source_country\"] = report[\"source\"][\"country\"]\n        del row[\"source\"]\n        row[\"subject\"] = report[\"parsed_sample\"][\"subject\"]\n        row[\"auth_failure\"] = \",\".join(report[\"auth_failure\"])\n        authentication_mechanisms = report[\"authentication_mechanisms\"]\n        row[\"authentication_mechanisms\"] = \",\".join(\n            authentication_mechanisms)\n        del row[\"sample\"]\n        del row[\"parsed_sample\"]\n        csv_writer.writerow(row)\n    return csv_file.getvalue()"
    },
    {
        "code": "def print_processor_inputs(self, processor_name):\n        p = self.processors(processor_name=processor_name)\n        if len(p) == 1:\n            p = p[0]\n        else:\n            Exception('Invalid processor name')\n        for field_schema, _, _ in iterate_schema({}, p['input_schema'], 'input'):\n            name = field_schema['name']\n            typ = field_schema['type']\n            print(\"{} -> {}\".format(name, typ))"
    },
    {
        "code": "def add_price_entity(self, price: dal.Price):\n        from decimal import Decimal\n        repo = self.get_price_repository()\n        existing = (\n            repo.query\n            .filter(dal.Price.namespace == price.namespace)\n            .filter(dal.Price.symbol == price.symbol)\n            .filter(dal.Price.date == price.date)\n            .filter(dal.Price.time == price.time)\n            .first()\n        )\n        if existing:\n            new_value = Decimal(price.value) / Decimal(price.denom)\n            self.logger.info(f\"Exists: {price}\")\n            if price.currency != existing.currency:\n                raise ValueError(\n                    f\"The currency is different for price {price}!\")\n            if existing.value != price.value:\n                existing.value = price.value\n                self.logger.info(f\"Updating to {new_value}.\")\n            if existing.denom != price.denom:\n                existing.denom = price.denom\n        else:\n            self.session.add(price)\n            self.logger.info(f\"Added {price}\")"
    },
    {
        "code": "def _load_features_from_images(self, images, names=None):\n        if names is not None and len(names) != len(images):\n            raise Exception(\n                \"Lists of feature names and images must be of same length!\")\n        self.feature_names = names if names is not None else images\n        self.feature_images = imageutils.load_imgs(images, self.masker)"
    },
    {
        "code": "def remove_chain(self, name):\n        if name in self.chains:\n            delattr(self.chains, name)\n        else:\n            raise ValueError(\"Chain with this name not found\")"
    },
    {
        "code": "def _use_rev_b_archive(self, records, offset):\n        if type(self._ARCHIVE_REV_B) is bool:\n            return self._ARCHIVE_REV_B\n        data = ArchiveBStruct.unpack_from(records, offset)\n        if data['RecType'] == 0:\n            log.info('detected archive rev. B')\n            self._ARCHIVE_REV_B = True\n        else:\n            log.info('detected archive rev. A')\n            self._ARCHIVE_REV_B = False\n        return self._ARCHIVE_REV_B"
    },
    {
        "code": "def do_help(self, options, args, parser):\n        if options.help:\n            if self.classic:\n                self.help_fn(topic='help')\n            else:\n                self.help_fn(parser=parser)\n            return True\n        if \"help\" in options.actions:\n            if args:\n                for a in args:\n                    parser = CMDS.get(a)\n                    if parser:\n                        self.help_fn(parser=parser)\n                    else:\n                        self.help_fn(topic=a)\n            else:\n                self.help_fn(topic='help')\n            return True\n        if options.version:\n            self.help_fn(topic='version')\n            return True\n        return False"
    },
    {
        "code": "def register_routes(app):\n    from . import controllers\n    from flask.blueprints import Blueprint\n    for module in _import_submodules_from_package(controllers):\n        bp = getattr(module, 'bp')\n        if bp and isinstance(bp, Blueprint):\n            app.register_blueprint(bp)"
    },
    {
        "code": "def flush(self, timeout=60):\n        if timeout <= 0:\n            raise ErrBadTimeout\n        if self.is_closed:\n            raise ErrConnectionClosed\n        future = asyncio.Future(loop=self._loop)\n        try:\n            yield from self._send_ping(future)\n            yield from asyncio.wait_for(future, timeout, loop=self._loop)\n        except asyncio.TimeoutError:\n            future.cancel()\n            raise ErrTimeout"
    },
    {
        "code": "def match(self):\n        result = []\n        to_match = comp(self.regex)\n        if self.rematch:\n            pre_result = to_match.findall(self.data)\n        else:\n            pre_result = to_match.search(self.data)\n        if self.return_data and pre_result:\n            if self.rematch:\n                for data in pre_result:\n                    if isinstance(data, tuple):\n                        result.extend(list(data))\n                    else:\n                        result.append(data)\n                if self.group != 0:\n                    return result[self.group]\n            else:\n                result = pre_result.group(\n                    self.group\n                ).strip()\n            return result\n        if not self.return_data and pre_result:\n            return True\n        return False"
    },
    {
        "code": "def reset(self, new_session=True):\n        self.history_manager.reset(new_session)\n        if new_session:\n            self.execution_count = 1\n        if self.displayhook.do_full_cache:\n            self.displayhook.flush()\n        if self.user_ns is not self.user_global_ns:\n            self.user_ns.clear()\n        ns = self.user_global_ns\n        drop_keys = set(ns.keys())\n        drop_keys.discard('__builtin__')\n        drop_keys.discard('__builtins__')\n        drop_keys.discard('__name__')\n        for k in drop_keys:\n            del ns[k]\n        self.user_ns_hidden.clear()\n        self.init_user_ns()\n        self.alias_manager.clear_aliases()\n        self.alias_manager.init_aliases()\n        self.clear_main_mod_cache()\n        self.new_main_mod()"
    },
    {
        "code": "def event(uid):\n    db = get_session()\n    event = db.query(RecordedEvent).filter(RecordedEvent.uid == uid).first() \\\n        or db.query(UpcomingEvent).filter(UpcomingEvent.uid == uid).first()\n    if event:\n        return make_data_response(event.serialize())\n    return make_error_response('No event with specified uid', 404)"
    },
    {
        "code": "def parse_database_url(url):\n    if url == \"sqlite://:memory:\":\n        raise Exception(\n            'Your url is \"sqlite://:memory:\", if you want '\n            'an sqlite memory database, just use \"sqlite://\"'\n        )\n    url_parts = urlsplit(url)\n    engine = get_engine(url_parts.scheme)\n    database, schema = parse_path(url_parts.path)\n    port = url_parts.port\n    host = url_parts.hostname\n    user = url_parts.username\n    password = url_parts.password\n    params = {key: val.pop() for key, val in parse_qs(url_parts.query).items()}\n    return DatabaseInfo(\n        engine=engine,\n        name=database,\n        schema=schema,\n        user=user,\n        password=password,\n        host=host,\n        port=port,\n        params=params,\n    )"
    },
    {
        "code": "def _matmul(a, b,\n            transpose_a=False, transpose_b=False,\n            adjoint_a=False, adjoint_b=False,\n            a_is_sparse=False, b_is_sparse=False,\n            name=None):\n  if a_is_sparse or b_is_sparse:\n    raise NotImplementedError('Numpy backend does not support sparse matmul.')\n  if transpose_a or adjoint_a:\n    a = _matrix_transpose(a, conjugate=adjoint_a)\n  if transpose_b or adjoint_b:\n    b = _matrix_transpose(b, conjugate=adjoint_b)\n  return np.matmul(a, b)"
    },
    {
        "code": "def _broadcast_cat_event_and_params(event, params, base_dtype):\n  if dtype_util.is_integer(event.dtype):\n    pass\n  elif dtype_util.is_floating(event.dtype):\n    event = tf.cast(event, dtype=tf.int32)\n  else:\n    raise TypeError(\"`value` should have integer `dtype` or \"\n                    \"`self.dtype` ({})\".format(base_dtype))\n  shape_known_statically = (\n      tensorshape_util.rank(params.shape) is not None and\n      tensorshape_util.is_fully_defined(params.shape[:-1]) and\n      tensorshape_util.is_fully_defined(event.shape))\n  if not shape_known_statically or params.shape[:-1] != event.shape:\n    params *= tf.ones_like(event[..., tf.newaxis],\n                           dtype=params.dtype)\n    params_shape = tf.shape(input=params)[:-1]\n    event *= tf.ones(params_shape, dtype=event.dtype)\n    if tensorshape_util.rank(params.shape) is not None:\n      tensorshape_util.set_shape(event, params.shape[:-1])\n  return event, params"
    },
    {
        "code": "def add_patch(self, patch):\n        patchline = PatchLine(patch)\n        patch = patchline.get_patch()\n        if patch:\n            self.patch2line[patch] = patchline\n        self.patchlines.append(patchline)"
    },
    {
        "code": "def parse_rrset_record_values(e_resource_records):\n    records = []\n    for e_record in e_resource_records:\n        for e_value in e_record:\n            records.append(e_value.text)\n    return records"
    },
    {
        "code": "def verify_profile_name(msg, cfg):\n    if msg.profile not in cfg.data:\n        raise UnknownProfileError(msg.profile)"
    },
    {
        "code": "def bots(self):\n        json = self.skype.conn(\"GET\", \"{0}/agents\".format(SkypeConnection.API_BOT),\n                               auth=SkypeConnection.Auth.SkypeToken).json().get(\"agentDescriptions\", [])\n        return [self.merge(SkypeBotUser.fromRaw(self.skype, raw)) for raw in json]"
    },
    {
        "code": "def _makeApiCall(self, parameters=None):\n        r = self._apiClient.get(self._url, parameters)\n        if r.status_code == 200:\n            return r.json()\n        else:\n            raise Exception(\"HTTP %s %s\" % (r.status_code, r.text))"
    },
    {
        "code": "def volume_down(self):\n        self._volume_level -= self._volume_step / self._max_volume\n        self._device.vol_down(num=self._volume_step)"
    },
    {
        "code": "def bytesize(self, byteorder='@'):\n        seed_size = struct.calcsize(byteorder+'q')\n        length_size = struct.calcsize(byteorder+'i')\n        hashvalue_size = struct.calcsize(byteorder+'I')\n        return seed_size + length_size + len(self) * hashvalue_size"
    },
    {
        "code": "def get_certificate_from_publish_settings(publish_settings_path, path_to_write_certificate, subscription_id=None):\n    import base64\n    try:\n        from xml.etree import cElementTree as ET\n    except ImportError:\n        from xml.etree import ElementTree as ET\n    try:\n        import OpenSSL.crypto as crypto\n    except:\n        raise Exception(\"pyopenssl is required to use get_certificate_from_publish_settings\")\n    _validate_not_none('publish_settings_path', publish_settings_path)\n    _validate_not_none('path_to_write_certificate', path_to_write_certificate)\n    tree = ET.parse(publish_settings_path)\n    subscriptions = tree.getroot().findall(\"./PublishProfile/Subscription\")\n    if subscription_id:\n        subscription = next((s for s in subscriptions if s.get('Id').lower() == subscription_id.lower()), None)\n    else:\n        subscription = subscriptions[0]\n    if subscription is None:\n        raise ValueError(\"The provided subscription_id '{}' was not found in the publish settings file provided at '{}'\".format(subscription_id, publish_settings_path))\n    cert_string = _decode_base64_to_bytes(subscription.get('ManagementCertificate'))\n    cert = crypto.load_pkcs12(cert_string, b'') \n    with open(path_to_write_certificate, 'wb') as f:\n        f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert.get_certificate()))\n        f.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, cert.get_privatekey()))\n    return subscription.get('Id')"
    },
    {
        "code": "def wantClass(self, cls):\n        declared = getattr(cls, '__test__', None)\n        if declared is not None:\n            wanted = declared\n        else:\n            wanted = (not cls.__name__.startswith('_')\n                      and (issubclass(cls, unittest.TestCase)\n                           or self.matches(cls.__name__)))\n        plug_wants = self.plugins.wantClass(cls)        \n        if plug_wants is not None:\n            log.debug(\"Plugin setting selection of %s to %s\", cls, plug_wants)\n            wanted = plug_wants\n        log.debug(\"wantClass %s? %s\", cls, wanted)\n        return wanted"
    },
    {
        "code": "def t_NOTEQUAL(self, t):\n        r\"!\\=\"\n        t.endlexpos = t.lexpos + len(t.value)\n        return t"
    },
    {
        "code": "def get_dict(self, timeout=-1):\n        results = self.get(timeout)\n        engine_ids = [ md['engine_id'] for md in self._metadata ]\n        bycount = sorted(engine_ids, key=lambda k: engine_ids.count(k))\n        maxcount = bycount.count(bycount[-1])\n        if maxcount > 1:\n            raise ValueError(\"Cannot build dict, %i jobs ran on engine\n                    maxcount, bycount[-1]))\n        return dict(zip(engine_ids,results))"
    },
    {
        "code": "def create_file(self, bucket, key, file_versions):\n        objs = []\n        for file_ver in file_versions:\n            f = FileInstance.create().set_uri(\n                file_ver['full_path'],\n                file_ver['size'],\n                'md5:{0}'.format(file_ver['checksum']),\n            )\n            obj = ObjectVersion.create(bucket, key).set_file(f)\n            obj.created = arrow.get(\n                file_ver['creation_date']).datetime.replace(tzinfo=None)\n            objs.append(obj)\n        db.session.commit()\n        return objs[-1]"
    },
    {
        "code": "def cli_command_restart(self, msg):\n        info = ''\n        if self.state == State.RUNNING and self.sprocess and self.sprocess.proc:\n            self.state = State.RESTARTING\n            self.sprocess.set_exit_callback(self.proc_exit_cb_restart)\n            self.sprocess.proc.kill()\n            info = 'killed'\n        return info"
    },
    {
        "code": "def _reconstruct_matrix(data_list):\n        matrix_format = data_list[0]\n        data = data_list[1]\n        is_empty = isinstance(data, str) and data == '__empty__'\n        if matrix_format == 'csc':\n            if is_empty:\n                return spsp.csc_matrix(data_list[4])\n            else:\n                return spsp.csc_matrix(tuple(data_list[1:4]), shape=data_list[4])\n        elif matrix_format == 'csr':\n            if is_empty:\n                return spsp.csr_matrix(data_list[4])\n            else:\n                return spsp.csr_matrix(tuple(data_list[1:4]), shape=data_list[4])\n        elif matrix_format == 'bsr':\n            if is_empty:\n                return spsp.bsr_matrix(data_list[4])\n            else:\n                return spsp.bsr_matrix(tuple(data_list[1:4]), shape=data_list[4])\n        elif matrix_format == 'dia':\n            if is_empty:\n                return spsp.dia_matrix(data_list[3])\n            else:\n                return spsp.dia_matrix(tuple(data_list[1:3]), shape=data_list[3])\n        else:\n            raise RuntimeError('You shall not pass!')"
    },
    {
        "code": "def pull(dry_run, flavor, interactive, debug):\n    try:\n        main_section = _get_section_name(flavor)\n        config = _try_load_config(main_section, interactive)\n        lockfile_path = os.path.join(get_data_path(config, main_section),\n                                     'bugwarrior.lockfile')\n        lockfile = PIDLockFile(lockfile_path)\n        lockfile.acquire(timeout=10)\n        try:\n            issue_generator = aggregate_issues(config, main_section, debug)\n            synchronize(issue_generator, config, main_section, dry_run)\n        finally:\n            lockfile.release()\n    except LockTimeout:\n        log.critical(\n            'Your taskrc repository is currently locked. '\n            'Remove the file at %s if you are sure no other '\n            'bugwarrior processes are currently running.' % (\n                lockfile_path\n            )\n        )\n    except RuntimeError as e:\n        log.exception(\"Aborted (%s)\" % e)"
    },
    {
        "code": "def label_search(self, key=None, value=None):\n    if key is not None:\n        key = key.lower()\n    if value is not None:\n        value = value.lower()\n    show_details = True\n    if key is None and value is None:\n        url = '%s/labels/search' % (self.base)\n        show_details = False\n    elif key is not None and value is not None:\n        url = '%s/labels/search/%s/key/%s/value' % (self.base, key, value)\n    elif key is None:\n        url = '%s/labels/search/%s/value' % (self.base, value)\n    else:\n        url = '%s/labels/search/%s/key' % (self.base, key)\n    result = self._get(url)\n    if len(result) == 0:\n        bot.info(\"No labels found.\")\n        sys.exit(0)\n    bot.info(\"Labels\\n\")\n    rows = []\n    for l in result:        \n        if show_details is True:\n            entry = [\"%s:%s\" %(l['key'],l['value']),\n                     \"\\n%s\\n\\n\" %\"\\n\".join(l['containers'])]\n        else:\n            entry = [\"N=%s\" %len(l['containers']),\n                    \"%s:%s\" %(l['key'],l['value']) ]\n        rows.append(entry)\n    bot.table(rows)\n    return rows"
    },
    {
        "code": "def force_iterable(f):\n    def wrapper(*args, **kwargs):\n        r = f(*args, **kwargs)\n        if hasattr(r, '__iter__'):\n            return r\n        else:\n            return [r]\n    return wrapper"
    },
    {
        "code": "def main():\n    args = get_args()\n    ret_code = args.target(args)\n    _logger.debug('Exiting with code %d', ret_code)\n    sys.exit(ret_code)"
    },
    {
        "code": "def lock(fileobj):\n    try:\n        import fcntl\n    except ImportError:\n        return False\n    else:\n        try:\n            fcntl.lockf(fileobj, fcntl.LOCK_EX)\n        except IOError:\n            return False\n        else:\n            return True"
    },
    {
        "code": "def make_bintree(levels):\n    G = nx.DiGraph()\n    root = '0'\n    G.add_node(root)\n    add_children(G, root, levels, 2)\n    return G"
    },
    {
        "code": "def set_option(self, optname, value, action=None, optdict=None):\n        if optname in self._options_methods or optname in self._bw_options_methods:\n            if value:\n                try:\n                    meth = self._options_methods[optname]\n                except KeyError:\n                    meth = self._bw_options_methods[optname]\n                    warnings.warn(\n                        \"%s is deprecated, replace it by %s\"\n                        % (optname, optname.split(\"-\")[0]),\n                        DeprecationWarning,\n                    )\n                value = utils._check_csv(value)\n                if isinstance(value, (list, tuple)):\n                    for _id in value:\n                        meth(_id, ignore_unknown=True)\n                else:\n                    meth(value)\n                return\n        elif optname == \"output-format\":\n            self._reporter_name = value\n            if self._reporters:\n                self._load_reporter()\n        try:\n            checkers.BaseTokenChecker.set_option(self, optname, value, action, optdict)\n        except config.UnsupportedAction:\n            print(\"option %s can't be read from config file\" % optname, file=sys.stderr)"
    },
    {
        "code": "def _send_offer_assignment_notification_email(config, user_email, subject, email_body, site_code, task):\n    try:\n        sailthru_client = get_sailthru_client(site_code)\n    except SailthruError:\n        logger.exception(\n            '[Offer Assignment] A client error occurred while attempting to send a offer assignment notification.'\n            ' Message: {message}'.format(message=email_body)\n        )\n        return None\n    email_vars = {\n        'subject': subject,\n        'email_body': email_body,\n    }\n    try:\n        response = sailthru_client.send(\n            template=config['templates']['assignment_email'],\n            email=user_email,\n            _vars=email_vars\n        )\n    except SailthruClientError:\n        logger.exception(\n            '[Offer Assignment] A client error occurred while attempting to send a offer assignment notification.'\n            ' Message: {message}'.format(message=email_body)\n        )\n        return None\n    if not response.is_ok():\n        error = response.get_error()\n        logger.error(\n            '[Offer Assignment] A {token_error_code} - {token_error_message} error occurred'\n            ' while attempting to send a offer assignment notification.'\n            ' Message: {message}'.format(\n                message=email_body,\n                token_error_code=error.get_error_code(),\n                token_error_message=error.get_message()\n            )\n        )\n        if can_retry_sailthru_request(error):\n            logger.info(\n                '[Offer Assignment] An attempt will be made to resend the offer assignment notification.'\n                ' Message: {message}'.format(message=email_body)\n            )\n            schedule_retry(task, config)\n        else:\n            logger.warning(\n                '[Offer Assignment] No further attempts will be made to send the offer assignment notification.'\n                ' Failed Message: {message}'.format(message=email_body)\n            )\n    return response"
    },
    {
        "code": "def migrate(uri: str, archive_uri: str, case_id: str, dry: bool, force: bool):\n    scout_client = MongoClient(uri)\n    scout_database = scout_client[uri.rsplit('/', 1)[-1]]\n    scout_adapter = MongoAdapter(database=scout_database)\n    scout_case = scout_adapter.case(case_id)\n    if not force and scout_case.get('is_migrated'):\n        print(\"case already migrated\")\n        return\n    archive_client = MongoClient(archive_uri)\n    archive_database = archive_client[archive_uri.rsplit('/', 1)[-1]]\n    archive_case = archive_database.case.find_one({\n        'owner': scout_case['owner'],\n        'display_name': scout_case['display_name']\n    })\n    archive_data = archive_info(archive_database, archive_case)\n    if dry:\n        print(ruamel.yaml.safe_dump(archive_data))\n    else:\n        pass"
    },
    {
        "code": "def load_disease_term(self, disease_obj):\n        LOG.debug(\"Loading disease term %s into database\", disease_obj['_id'])\n        try:\n            self.disease_term_collection.insert_one(disease_obj)\n        except DuplicateKeyError as err:\n            raise IntegrityError(\"Disease term %s already exists in database\".format(disease_obj['_id']))\n        LOG.debug(\"Disease term saved\")"
    },
    {
        "code": "def get_elliptic_curve(name):\n    for curve in get_elliptic_curves():\n        if curve.name == name:\n            return curve\n    raise ValueError(\"unknown curve name\", name)"
    },
    {
        "code": "def subscribe(self):\n        self.stream.setsockopt(zmq.UNSUBSCRIBE, '')\n        if '' in self.topics:\n            self.log.debug(\"Subscribing to: everything\")\n            self.stream.setsockopt(zmq.SUBSCRIBE, '')\n        else:\n            for topic in self.topics:\n                self.log.debug(\"Subscribing to: %r\"%(topic))\n                self.stream.setsockopt(zmq.SUBSCRIBE, topic)"
    },
    {
        "code": "def _sem_open(name, value=None):\n    if value is None:\n        handle = pthread.sem_open(ctypes.c_char_p(name), 0)\n    else:\n        handle = pthread.sem_open(ctypes.c_char_p(name), SEM_OFLAG, SEM_PERM,\n                                  ctypes.c_int(value))\n    if handle == SEM_FAILURE:\n        e = ctypes.get_errno()\n        if e == errno.EEXIST:\n            raise FileExistsError(\"a semaphore named %s already exists\" % name)\n        elif e == errno.ENOENT:\n            raise FileNotFoundError('cannot find semaphore named %s' % name)\n        elif e == errno.ENOSYS:\n            raise NotImplementedError('No semaphore implementation on this '\n                                      'system')\n        else:\n            raiseFromErrno()\n    return handle"
    },
    {
        "code": "def parallel(collection, method, processes=None, args=None, **kwargs):\n    if processes is None:\n        processes = min(mp.cpu_count(), 20)\n    print \"Running parallel process on \" + str(processes) + \" cores. :-)\"\n    pool = mp.Pool(processes=processes)\n    PROC = []\n    tic = time.time()\n    for main_arg in collection:\n        if args is None:\n            ARGS = (main_arg,)\n        else:\n            if isinstance(args, tuple) == False:\n                args = (args,)\n            ARGS = (main_arg,) + args\n        PROC.append(pool.apply_async(method, args=ARGS, kwds=kwargs))\n    RES = []\n    for p in PROC:\n        try:\n            RES.append(p.get())\n        except Exception as e:\n            print \"shit happens...\"\n            print e\n            RES.append(None)\n    pool.close()\n    pool.join()\n    toc = time.time()\n    elapsed = toc - tic\n    print \"Elapsed time: %s  on %s processes :-)\\n\" % (str(elapsed), str(processes))\n    return RES"
    },
    {
        "code": "def uncache_zipdir(path):\n    from zipimport import _zip_directory_cache as zdc\n    _uncache(path, zdc)\n    _uncache(path, sys.path_importer_cache)"
    },
    {
        "code": "def task_create(asana_workspace_id, name, notes, assignee, projects,\n                completed, **kwargs):\n    put(\"task_create\",\n        asana_workspace_id=asana_workspace_id,\n        name=name,\n        notes=notes,\n        assignee=assignee,\n        projects=projects,\n        completed=completed,\n        **kwargs)"
    },
    {
        "code": "def str_to_num(str_value):\n        str_value = str(str_value)\n        try:\n            return int(str_value)\n        except ValueError:\n            return float(str_value)"
    },
    {
        "code": "def connect(url='https://github.com', token=None):\n    gh_session = None\n    if url == 'https://github.com':\n        gh_session = create_session(token)\n    else:\n        gh_session = create_enterprise_session(url, token)\n    if gh_session is None:\n        msg = 'Unable to connect to (%s) with provided token.'\n        raise RuntimeError(msg, url)\n    logger.info('Connected to: %s', url)\n    return gh_session"
    },
    {
        "code": "def generate_project(args):\n    src = os.path.join(dirname(abspath(__file__)), 'project')\n    project_name = args.get('<project>')\n    if not project_name:\n        logger.warning('Project name cannot be empty.')\n        return\n    dst = os.path.join(os.getcwd(), project_name)\n    if os.path.isdir(dst):\n        logger.warning('Project directory already exists.')\n        return\n    logger.info('Start generating project files.')\n    _mkdir_p(dst)\n    for src_dir, sub_dirs, filenames in os.walk(src):\n        relative_path = src_dir.split(src)[1].lstrip(os.path.sep)\n        dst_dir = os.path.join(dst, relative_path)\n        if src != src_dir:\n            _mkdir_p(dst_dir)\n        for filename in filenames:\n            if filename in ['development.py', 'production.py']:\n                continue\n            src_file = os.path.join(src_dir, filename)\n            dst_file = os.path.join(dst_dir, filename)\n            if filename.endswith(REWRITE_FILE_EXTS):\n                _rewrite_and_copy(src_file, dst_file, project_name)\n            else:\n                shutil.copy(src_file, dst_file)\n            logger.info(\"New: %s\" % dst_file)\n            if filename in ['development_sample.py', 'production_sample.py']:\n                dst_file = os.path.join(dst_dir, \"%s.py\" % filename.split('_')[0])\n                _rewrite_and_copy(src_file, dst_file, project_name)\n                logger.info(\"New: %s\" % dst_file)\n    logger.info('Finish generating project files.')"
    },
    {
        "code": "def with_ignored_exceptions(self, *ignored_exceptions):\n        for exception in ignored_exceptions:\n            self._ignored_exceptions = self._ignored_exceptions + (exception,)\n        return self"
    },
    {
        "code": "def indented_short_title(self, item):\n        r = \"\"\n        if hasattr(item, 'get_absolute_url'):\n            r = '<input type=\"hidden\" class=\"medialibrary_file_path\" value=\"%s\" />' % item.get_absolute_url()\n        editable_class = ''\n        if not getattr(item, 'feincms_editable', True):\n            editable_class = ' tree-item-not-editable'\n        r += '<span id=\"page_marker-%d\" class=\"page_marker%s\" style=\"width: %dpx;\">&nbsp;</span>&nbsp;' % (\n            item.id, editable_class, 14 + item.level * 18)\n        if hasattr(item, 'short_title'):\n            r += item.short_title()\n        else:\n            r += unicode(item)\n        return mark_safe(r)"
    },
    {
        "code": "def render_columns(columns, write_borders=True, column_colors=None):\n    if column_colors is not None and len(column_colors) != len(columns):\n        raise ValueError('Wrong number of column colors')\n    widths = [max(len(cell) for cell in column) for column in columns]\n    max_column_length = max(len(column) for column in columns)\n    result = '\\n'.join(render_row(i, columns, widths, column_colors)\n                       for i in range(max_column_length))\n    if write_borders:\n        border = '+%s+' % '|'.join('-' * (w + 2) for w in widths)\n        return '%s\\n%s\\n%s' % (border, result, border)\n    else:\n        return result"
    },
    {
        "code": "def create_database(self, server_name, name, service_objective_id,\n                        edition=None, collation_name=None,\n                        max_size_bytes=None):\n        _validate_not_none('server_name', server_name)\n        _validate_not_none('name', name)\n        _validate_not_none('service_objective_id', service_objective_id)\n        return self._perform_post(\n            self._get_databases_path(server_name),\n            _SqlManagementXmlSerializer.create_database_to_xml(\n                name, service_objective_id, edition, collation_name,\n                max_size_bytes\n            )\n        )"
    },
    {
        "code": "def xcom_push(\n            self,\n            key,\n            value,\n            execution_date=None):\n        if execution_date and execution_date < self.execution_date:\n            raise ValueError(\n                'execution_date can not be in the past (current '\n                'execution_date is {}; received {})'.format(\n                    self.execution_date, execution_date))\n        XCom.set(\n            key=key,\n            value=value,\n            task_id=self.task_id,\n            dag_id=self.dag_id,\n            execution_date=execution_date or self.execution_date)"
    },
    {
        "code": "def merged(self, timeslots: 'TimeslotCollection') -> 'TimeslotCollection':\n        slots = [Timeslot(slot.interval, slot.channel) for slot in self.timeslots]\n        slots.extend([Timeslot(slot.interval, slot.channel) for slot in timeslots.timeslots])\n        return TimeslotCollection(*slots)"
    },
    {
        "code": "def concat(*seqs) -> ISeq:\n    allseqs = lseq.sequence(itertools.chain(*filter(None, map(to_seq, seqs))))\n    if allseqs is None:\n        return lseq.EMPTY\n    return allseqs"
    },
    {
        "code": "def _set_logger(self, name=None):\n        if name is None:\n            cls = self.__class__\n            name = '%s.%s' % (cls.__module__, cls.__name__)\n        self._logger = logging.getLogger(name)"
    },
    {
        "code": "def as_event_description(self):\n        description = {\n            self.name: {\n                'timestamp': self.time,\n            },\n        }\n        if self.data is not None:\n            description[self.name]['data'] = self.data\n        return description"
    },
    {
        "code": "def add_element(self, element):\n        if isinstance(element, BaseExpression):\n            element.set_parent(self._working_fragment)\n            self._working_fragment.elements.append(element)\n            return self\n        else:\n            return self.add_operator(element)"
    },
    {
        "code": "def hub_history(self):\n        self.session.send(self._query_socket, \"history_request\", content={})\n        idents, msg = self.session.recv(self._query_socket, 0)\n        if self.debug:\n            pprint(msg)\n        content = msg['content']\n        if content['status'] != 'ok':\n            raise self._unwrap_exception(content)\n        else:\n            return content['history']"
    },
    {
        "code": "def mk_privkeys(num):\n    \"make privkeys that support coloring, see utils.cstr\"\n    privkeys = []\n    assert num <= num_colors\n    for i in range(num):\n        j = 0\n        while True:\n            k = sha3(str(j))\n            a = privtoaddr(k)\n            an = big_endian_to_int(a)\n            if an % num_colors == i:\n                break\n            j += 1\n        privkeys.append(k)\n    return privkeys"
    },
    {
        "code": "def parse_list(value):\n    segments = _QUOTED_SEGMENT_RE.findall(value)\n    for segment in segments:\n        left, match, right = value.partition(segment)\n        value = ''.join([left, match.replace(',', '\\000'), right])\n    return [_dequote(x.strip()).replace('\\000', ',')\n            for x in value.split(',')]"
    },
    {
        "code": "def index(context):\n    LOG.info(\"Running scout delete index\")\n    adapter = context.obj['adapter']\n    for collection in adapter.db.collection_names():\n        adapter.db[collection].drop_indexes()\n    LOG.info(\"All indexes deleted\")"
    },
    {
        "code": "def is_valid_filesys(path):\n        if os.path.isabs(path) and os.path.isdir(path) and \\\n                not os.path.isfile(path):\n            return True\n        else:\n            raise LocalPortValidationError(\n                'Port value %s is not a valid filesystem location' % path\n            )"
    },
    {
        "code": "def parse_coordinates(variant, category):\n    ref = variant.REF\n    if variant.ALT:\n        alt = variant.ALT[0]\n    if category==\"str\" and not variant.ALT:\n        alt = '.'\n    chrom_match = CHR_PATTERN.match(variant.CHROM)\n    chrom = chrom_match.group(2)\n    svtype = variant.INFO.get('SVTYPE')\n    if svtype:\n        svtype = svtype.lower()\n    mate_id = variant.INFO.get('MATEID')\n    svlen = variant.INFO.get('SVLEN')\n    svend = variant.INFO.get('END')\n    snvend = int(variant.end)\n    position = int(variant.POS)\n    ref_len = len(ref)\n    alt_len = len(alt)\n    sub_category = get_sub_category(alt_len, ref_len, category, svtype)\n    end = get_end(position, alt, category, snvend, svend)\n    length = get_length(alt_len, ref_len, category, position, end, svtype, svlen)\n    end_chrom = chrom\n    if sub_category == 'bnd':\n        if ':' in alt:\n            match = BND_ALT_PATTERN.match(alt)\n            if match:\n                other_chrom = match.group(1)\n                match = CHR_PATTERN.match(other_chrom)\n                end_chrom = match.group(2)\n    cytoband_start = get_cytoband_coordinates(chrom, position)\n    cytoband_end = get_cytoband_coordinates(end_chrom, end)\n    coordinates = {\n        'position': position,\n        'end': end,\n        'length': length,\n        'sub_category': sub_category,\n        'mate_id': mate_id,\n        'cytoband_start': cytoband_start,\n        'cytoband_end': cytoband_end,\n        'end_chrom': end_chrom,\n    }\n    return coordinates"
    },
    {
        "code": "def get_metadata(path_or_module, metadata_version=None):\n    if isinstance(path_or_module, ModuleType):\n        try:\n            return Installed(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass\n    try:\n        __import__(path_or_module)\n    except ImportError:\n        pass\n    else:\n        try:\n            return Installed(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass\n    if os.path.isfile(path_or_module):\n        try:\n            return SDist(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass\n        try:\n            return BDist(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass\n        try:\n            return Wheel(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass\n    if os.path.isdir(path_or_module):\n        try:\n            return Develop(path_or_module, metadata_version)\n        except (ValueError, IOError):\n            pass"
    },
    {
        "code": "def unsubscribe(self, event, callback):\n        try:\n            self._subscribers[event].remove(self._Subscription(event, callback))\n        except KeyError:\n            return False\n        return True"
    },
    {
        "code": "def to_archive(self, writer):\n        if 'b' not in writer.mode:\n            raise GiraffeError(\"Archive writer must be in binary mode\")\n        writer.write(GIRAFFE_MAGIC)\n        writer.write(self.columns.serialize())\n        i = 0\n        for n, chunk in enumerate(self._fetchall(ROW_ENCODING_RAW), 1):\n            writer.write(chunk)\n            yield TeradataEncoder.count(chunk)"
    },
    {
        "code": "def flatten(iterables, level=inf):\n    if level >= 0 and isinstance(iterables, (list, tuple, GeneratorType,\n                                             map, zip)):\n        level -= 1\n        for i in iterables:\n            yield from flatten(i, level=level)\n    else:\n        yield iterables"
    },
    {
        "code": "def send(self):\n        self._generate_email()\n        if self.verbose:\n            print(\n                \"Debugging info\"\n                \"\\n--------------\"\n                \"\\n{} Message created.\".format(timestamp())\n            )\n        recipients = []\n        for i in (self.to, self.cc, self.bcc):\n            if i:\n                if isinstance(i, MutableSequence):\n                    recipients += i\n                else:\n                    recipients.append(i)\n        session = self._get_session()\n        if self.verbose:\n            print(timestamp(), \"Login successful.\")\n        session.sendmail(self.from_, recipients, self.message.as_string())\n        session.quit()\n        if self.verbose:\n            print(timestamp(), \"Logged out.\")\n        if self.verbose:\n            print(\n                timestamp(),\n                type(self).__name__ + \" info:\",\n                self.__str__(indentation=\"\\n * \"),\n            )\n        print(\"Message sent.\")"
    },
    {
        "code": "def node(self, title, **args):\n        self._stream.write('%snode: {title:\"%s\"' % (self._indent, title))\n        self._write_attributes(NODE_ATTRS, **args)\n        self._stream.write(\"}\\n\")"
    },
    {
        "code": "def _next_rdelim(items, pos):\n    for num, item in enumerate(items):\n        if item > pos:\n            break\n    else:\n        raise RuntimeError(\"Mismatched delimiters\")\n    del items[num]\n    return item"
    },
    {
        "code": "def _extract_base(self, element):\n        if isinstance(element, list):\n            return [self._extract_base(x) for x in element]\n        base = self.checker.is_url_valid(url=element, return_base=True)\n        if base:\n            return base\n        if \"/\" in element:\n            return element.split(\"/\")[0]\n        return element"
    },
    {
        "code": "def recent(self):\n        url = \"{0}/users/ME/conversations\".format(self.skype.conn.msgsHost)\n        params = {\"startTime\": 0,\n                  \"view\": \"msnp24Equivalent\",\n                  \"targetType\": \"Passport|Skype|Lync|Thread\"}\n        resp = self.skype.conn.syncStateCall(\"GET\", url, params, auth=SkypeConnection.Auth.RegToken).json()\n        chats = {}\n        for json in resp.get(\"conversations\", []):\n            cls = SkypeSingleChat\n            if \"threadProperties\" in json:\n                info = self.skype.conn(\"GET\", \"{0}/threads/{1}\".format(self.skype.conn.msgsHost, json.get(\"id\")),\n                                       auth=SkypeConnection.Auth.RegToken,\n                                       params={\"view\": \"msnp24Equivalent\"}).json()\n                json.update(info)\n                cls = SkypeGroupChat\n            chats[json.get(\"id\")] = self.merge(cls.fromRaw(self.skype, json))\n        return chats"
    },
    {
        "code": "def _html_checker(job_var, interval, status, header,\n                  _interval_set=False):\n    job_status = job_var.status()\n    job_status_name = job_status.name\n    job_status_msg = job_status.value\n    status.value = header % (job_status_msg)\n    while job_status_name not in ['DONE', 'CANCELLED']:\n        time.sleep(interval)\n        job_status = job_var.status()\n        job_status_name = job_status.name\n        job_status_msg = job_status.value\n        if job_status_name == 'ERROR':\n            break\n        else:\n            if job_status_name == 'QUEUED':\n                job_status_msg += ' (%s)' % job_var.queue_position()\n                if not _interval_set:\n                    interval = max(job_var.queue_position(), 2)\n            else:\n                if not _interval_set:\n                    interval = 2\n            status.value = header % (job_status_msg)\n    status.value = header % (job_status_msg)"
    },
    {
        "code": "def display(self):\n        if isinstance(self.name, six.string_types) and len(self.name) > 0:\n            return '{0} ({1})'.format(self.name, self.public_ip)\n        else:\n            return self.public_ip"
    },
    {
        "code": "def parse_conservation(variant, info_key):\n    raw_score = variant.INFO.get(info_key)\n    conservations = []\n    if raw_score:\n        if isinstance(raw_score, numbers.Number):\n            raw_score = (raw_score,)\n        for score in raw_score:\n            if score >= CONSERVATION[info_key]['conserved_min']:\n                conservations.append('Conserved')\n            else:\n                conservations.append('NotConserved')\n    return conservations"
    },
    {
        "code": "def _asa_task(q, masks, stft, sample_width, frame_rate, nsamples_for_each_fft):\n    for mask in masks:\n        mask = np.where(mask > 0, 1, 0)\n    masks = [mask * stft for mask in masks]\n    nparrs = []\n    dtype_dict = {1: np.int8, 2: np.int16, 4: np.int32}\n    dtype = dtype_dict[sample_width]\n    for m in masks:\n        _times, nparr = signal.istft(m, frame_rate, nperseg=nsamples_for_each_fft)\n        nparr = nparr.astype(dtype)\n        nparrs.append(nparr)\n    for m in nparrs:\n        q.put(m)\n    q.put(\"DONE\")"
    },
    {
        "code": "def client_authentication_required(self, request, *args, **kwargs):\n        def is_confidential(client):\n            if hasattr(client, 'is_confidential'):\n                return client.is_confidential\n            client_type = getattr(client, 'client_type', None)\n            if client_type:\n                return client_type == 'confidential'\n            return True\n        grant_types = ('password', 'authorization_code', 'refresh_token')\n        client_id, _ = self._get_client_creds_from_request(request)\n        if client_id and request.grant_type in grant_types:\n            client = self._clientgetter(client_id)\n            if client:\n                return is_confidential(client)\n        return False"
    },
    {
        "code": "def contains(self, k):\n        if self._changed():\n            self._read()\n        return k in self.store.keys()"
    },
    {
        "code": "def assert_is_type(var, *types, **kwargs):\n    assert types, \"The list of expected types was not provided\"\n    expected_type = types[0] if len(types) == 1 else U(*types)\n    if _check_type(var, expected_type): return\n    assert set(kwargs).issubset({\"message\", \"skip_frames\"}), \"Unexpected keyword arguments: %r\" % kwargs\n    message = kwargs.get(\"message\", None)\n    skip_frames = kwargs.get(\"skip_frames\", 1)\n    args = _retrieve_assert_arguments()\n    vname = args[0]\n    etn = _get_type_name(expected_type, dump=\", \".join(args[1:]))\n    vtn = _get_type_name(type(var))\n    raise H2OTypeError(var_name=vname, var_value=var, var_type_name=vtn, exp_type_name=etn, message=message,\n                       skip_frames=skip_frames)"
    },
    {
        "code": "def success(self):\n        any_success = False\n        for step_event in itertools.chain(\n            self.input_expectations, self.output_expectations, self.transforms\n        ):\n            if step_event.event_type == DagsterEventType.STEP_FAILURE:\n                return False\n            if step_event.event_type == DagsterEventType.STEP_SUCCESS:\n                any_success = True\n        return any_success"
    },
    {
        "code": "def session_new(self, **kwargs):\n        path = self._get_path('session_new')\n        response = self._GET(path, kwargs)\n        self._set_attrs_to_values(response)\n        return response"
    },
    {
        "code": "def filter_new(self, name, filt_str):\n        filt = self.filt.grab_filt(filt=filt_str)\n        self.filt.add(name, filt, info=filt_str)\n        return"
    },
    {
        "code": "def _observe_mode(self, change):\n        block = self.block\n        if block and self.is_initialized and change['type'] == 'update':\n            if change['oldvalue'] == 'replace':\n                raise NotImplementedError\n            for c in self.children:\n                block.children.remove(c)\n                c.set_parent(None)\n            self.refresh_items()"
    },
    {
        "code": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):\n        super(GetAttributeListResponsePayload, self).read(\n            input_buffer,\n            kmip_version=kmip_version\n        )\n        local_buffer = utils.BytearrayStream(input_buffer.read(self.length))\n        if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):\n            self._unique_identifier = primitives.TextString(\n                tag=enums.Tags.UNIQUE_IDENTIFIER\n            )\n            self._unique_identifier.read(\n                local_buffer,\n                kmip_version=kmip_version\n            )\n        else:\n            raise exceptions.InvalidKmipEncoding(\n                \"The GetAttributeList response payload encoding is missing \"\n                \"the unique identifier.\"\n            )\n        names = list()\n        if kmip_version < enums.KMIPVersion.KMIP_2_0:\n            while self.is_tag_next(enums.Tags.ATTRIBUTE_NAME, local_buffer):\n                name = primitives.TextString(tag=enums.Tags.ATTRIBUTE_NAME)\n                name.read(local_buffer, kmip_version=kmip_version)\n                names.append(name)\n            if len(names) == 0:\n                raise exceptions.InvalidKmipEncoding(\n                    \"The GetAttributeList response payload encoding is \"\n                    \"missing the attribute names.\"\n                )\n            self._attribute_names = names\n        else:\n            while self.is_tag_next(\n                    enums.Tags.ATTRIBUTE_REFERENCE,\n                    local_buffer\n            ):\n                if self.is_type_next(enums.Types.STRUCTURE, local_buffer):\n                    reference = objects.AttributeReference()\n                    reference.read(local_buffer, kmip_version=kmip_version)\n                    names.append(\n                        primitives.TextString(\n                            value=reference.attribute_name,\n                            tag=enums.Tags.ATTRIBUTE_NAME\n                        )\n                    )\n                elif self.is_type_next(enums.Types.ENUMERATION, local_buffer):\n                    reference = primitives.Enumeration(\n                        enums.Tags,\n                        tag=enums.Tags.ATTRIBUTE_REFERENCE\n                    )\n                    reference.read(local_buffer, kmip_version=kmip_version)\n                    name = enums.convert_attribute_tag_to_name(reference.value)\n                    names.append(\n                        primitives.TextString(\n                            value=name,\n                            tag=enums.Tags.ATTRIBUTE_NAME\n                        )\n                    )\n                else:\n                    raise exceptions.InvalidKmipEncoding(\n                        \"The GetAttributeList response payload encoding \"\n                        \"contains an invalid AttributeReference type.\"\n                    )\n            self._attribute_names = names\n        self.is_oversized(local_buffer)"
    },
    {
        "code": "def registerAdminSite(appName, excludeModels=[]):\n    for model in apps.get_app_config(appName).get_models():\n        if model not in excludeModels:\n            admin.site.register(model)"
    },
    {
        "code": "def _load_rels(self, source):\n\t\tself.relationships.load(source=self, data=source)"
    },
    {
        "code": "def protocol_version_to_kmip_version(value):\n    if not isinstance(value, ProtocolVersion):\n        return None\n    if value.major == 1:\n        if value.minor == 0:\n            return enums.KMIPVersion.KMIP_1_0\n        elif value.minor == 1:\n            return enums.KMIPVersion.KMIP_1_1\n        elif value.minor == 2:\n            return enums.KMIPVersion.KMIP_1_2\n        elif value.minor == 3:\n            return enums.KMIPVersion.KMIP_1_3\n        elif value.minor == 4:\n            return enums.KMIPVersion.KMIP_1_4\n        else:\n            return None\n    else:\n        return None"
    },
    {
        "code": "def genes_by_alias(self, build='37', genes=None):\n        LOG.info(\"Fetching all genes by alias\")\n        alias_genes = {}\n        if not genes:\n            genes = self.hgnc_collection.find({'build':build})\n        for gene in genes:\n            hgnc_id = gene['hgnc_id']\n            hgnc_symbol = gene['hgnc_symbol']\n            for alias in gene['aliases']:\n                true_id = None\n                if alias == hgnc_symbol:\n                    true_id = hgnc_id\n                if alias in alias_genes:\n                    alias_genes[alias]['ids'].add(hgnc_id)\n                    if true_id:\n                        alias_genes[alias]['true'] = hgnc_id\n                else:\n                    alias_genes[alias] = {\n                        'true': hgnc_id,\n                        'ids': set([hgnc_id])\n                    }\n        return alias_genes"
    },
    {
        "code": "def _expand_to_event_rank(self, x):\n    expanded_x = x\n    for _ in range(tensorshape_util.rank(self.event_shape)):\n      expanded_x = tf.expand_dims(expanded_x, -1)\n    return expanded_x"
    },
    {
        "code": "def start(self):\n        if self._collectors:\n            self._collectors[-1].pause()\n        self._collectors.append(self)\n        traces0 = []\n        if hasattr(sys, \"gettrace\"):\n            fn0 = sys.gettrace()\n            if fn0:\n                tracer0 = getattr(fn0, '__self__', None)\n                if tracer0:\n                    traces0 = getattr(tracer0, 'traces', [])\n        fn = self._start_tracer()\n        for args in traces0:\n            (frame, event, arg), lineno = args\n            try:\n                fn(frame, event, arg, lineno=lineno)\n            except TypeError:\n                raise Exception(\n                    \"fullcoverage must be run with the C trace function.\"\n                )\n        threading.settrace(self._installation_trace)"
    },
    {
        "code": "def _has_connection(hostname, port):\n    try:\n        host = socket.gethostbyname(hostname)\n        socket.create_connection((host, port), 2)\n        return True\n    except Exception:\n        return False"
    },
    {
        "code": "def rps_at(self, t):\n        if 0 <= t <= self.duration:\n            return self.minrps + \\\n                float(self.maxrps - self.minrps) * t / self.duration\n        else:\n            return 0"
    },
    {
        "code": "def get_all_child_m2m_relations(model):\n    return [\n        field for field in model._meta.get_fields()\n        if isinstance(field, ParentalManyToManyField)\n    ]"
    },
    {
        "code": "def display_json(*objs, **kwargs):\n    raw = kwargs.pop('raw',False)\n    if raw:\n        for obj in objs:\n            publish_json(obj)\n    else:\n        display(*objs, include=['text/plain','application/json'])"
    },
    {
        "code": "def pick_scalar_condition(pred, true_value, false_value, name=None):\n  with tf.name_scope(name or \"pick_scalar_condition\"):\n    pred = tf.convert_to_tensor(\n        value=pred, dtype_hint=tf.bool, name=\"pred\")\n    true_value = tf.convert_to_tensor(value=true_value, name=\"true_value\")\n    false_value = tf.convert_to_tensor(value=false_value, name=\"false_value\")\n    pred_ = tf.get_static_value(pred)\n    if pred_ is None:\n      return tf.where(pred, true_value, false_value)\n    return true_value if pred_ else false_value"
    },
    {
        "code": "def adapter(data, headers, table_format=None, **kwargs):\n    keys = ('title', )\n    table = table_format_handler[table_format]\n    t = table([headers] + list(data), **filter_dict_by_key(kwargs, keys))\n    dimensions = terminaltables.width_and_alignment.max_dimensions(\n        t.table_data,\n        t.padding_left,\n        t.padding_right)[:3]\n    for r in t.gen_table(*dimensions):\n        yield u''.join(r)"
    },
    {
        "code": "def print_hex(data):\n    hex_msg = \"\"\n    for c in data:\n        hex_msg += \"\\\\x\" + format(c, \"02x\")\n    _LOGGER.debug(hex_msg)"
    },
    {
        "code": "def fetch(self, category=CATEGORY_BUILD):\n        kwargs = {}\n        items = super().fetch(category, **kwargs)\n        return items"
    },
    {
        "code": "def _status_new(self):\n        self._update_status()\n        new_comp = self._group_report(self._comp_report, 'Completed')\n        new_dead = self._group_report(self._dead_report,\n                                      'Dead, call jobs.traceback() for details')\n        self._comp_report[:] = []\n        self._dead_report[:] = []\n        return new_comp or new_dead"
    },
    {
        "code": "def encode(self):\n        header    = bytearray(1)\n        varHeader = bytearray()\n        payload   = bytearray()\n        if self.qos:\n            header[0] = 0x30 | self.retain | (self.qos << 1) | (self.dup << 3)\n            varHeader.extend(encodeString(self.topic))\n            varHeader.extend(encode16Int(self.msgId))\n        else:\n            header[0] = 0x30 | self.retain\n            varHeader.extend(encodeString(self.topic))\n        if isinstance(self.payload, bytearray):\n            payload.extend(self.payload)\n        elif isinstance(self.payload, str):\n            payload.extend(bytearray(self.payload, encoding='utf-8'))\n        else:\n            raise PayloadTypeError(type(self.payload))\n        totalLen = len(varHeader) + len(payload)\n        if totalLen > 268435455:\n            raise PayloadValueError(totalLen)\n        header.extend(encodeLength(totalLen))\n        header.extend(varHeader)\n        header.extend(payload)\n        self.encoded = header\n        return str(header) if PY2 else bytes(header)"
    },
    {
        "code": "def symmetrized_csiszar_function(logu, csiszar_function, name=None):\n  with tf.compat.v1.name_scope(name, \"symmetrized_csiszar_function\", [logu]):\n    logu = tf.convert_to_tensor(value=logu, name=\"logu\")\n    return 0.5 * (csiszar_function(logu)\n                  + dual_csiszar_function(logu, csiszar_function))"
    },
    {
        "code": "def get_engine(scheme):\n    path = scheme.split(\"+\")\n    first, rest = path[0], path[1:]\n    second = rest[0] if rest else None\n    engine = resolve(ENGINE_MAPPING, first)\n    if not isinstance(engine, list):\n        if second:\n            raise KeyError(\"%s has no sub-engines\" % first)\n        return engine\n    try:\n        engine, extra = engine\n    except ValueError:\n        raise ValueError(\n            \"django-bananas.url' engine \"\n            \"configuration is invalid: %r\" % ENGINE_MAPPING\n        )\n    if second is not None:\n        engine = resolve(extra, second)\n    assert not isinstance(\n        engine, (list, dict)\n    ), \"Only two levels of engines \" \"are allowed\"\n    assert engine, \"The returned engine is not truthy\"\n    return engine"
    },
    {
        "code": "def export_to_storage_bucket(self, bucket, namespace=None, entity_filter=None, labels=None):\n        admin_conn = self.get_conn()\n        output_uri_prefix = 'gs://' + '/'.join(filter(None, [bucket, namespace]))\n        if not entity_filter:\n            entity_filter = {}\n        if not labels:\n            labels = {}\n        body = {\n            'outputUrlPrefix': output_uri_prefix,\n            'entityFilter': entity_filter,\n            'labels': labels,\n        }\n        resp = (admin_conn\n                .projects()\n                .export(projectId=self.project_id, body=body)\n                .execute(num_retries=self.num_retries))\n        return resp"
    },
    {
        "code": "def build_package_from_pr_number(gh_token, sdk_id, pr_number, output_folder, *, with_comment=False):\n    con = Github(gh_token)\n    repo = con.get_repo(sdk_id)\n    sdk_pr = repo.get_pull(pr_number)\n    package_names = {f.filename.split('/')[0] for f in sdk_pr.get_files() if f.filename.startswith(\"azure\")}\n    absolute_output_folder = Path(output_folder).resolve()\n    with tempfile.TemporaryDirectory() as temp_dir, \\\n            manage_git_folder(gh_token, Path(temp_dir) / Path(\"sdk\"), sdk_id, pr_number=pr_number) as sdk_folder:\n        for package_name in package_names:\n            _LOGGER.debug(\"Build {}\".format(package_name))\n            execute_simple_command(\n                [\"python\", \"./build_package.py\", \"--dest\", str(absolute_output_folder), package_name],\n                cwd=sdk_folder\n            )\n            _LOGGER.debug(\"Build finished: {}\".format(package_name))\n    if with_comment:\n        files = [f.name for f in absolute_output_folder.iterdir()]\n        comment_message = None\n        dashboard = DashboardCommentableObject(sdk_pr, \"(message created by the CI based on PR content)\")\n        try:\n            installation_message = build_installation_message(sdk_pr)\n            download_message = build_download_message(sdk_pr, files)\n            comment_message = installation_message + \"\\n\\n\" + download_message\n            dashboard.create_comment(comment_message)\n        except Exception:\n            _LOGGER.critical(\"Unable to do PR comment:\\n%s\", comment_message)"
    },
    {
        "code": "def verbose(self, msg, *args, **kwargs):\n        self.log(logging.VERBOSE, msg, *args, **kwargs)"
    },
    {
        "code": "def set_value(self, value):\n        self.validate_value(value)\n        self.value.set(value)"
    },
    {
        "code": "def remoteDataReceived(self, connection, data):\n        proto = self.getLocalProtocol(connection)\n        proto.transport.write(data)\n        return {}"
    },
    {
        "code": "def create_validator(data_struct_dict, name=None):\n    if name is None:\n        name = 'FromDictValidator'\n    attrs = {}\n    for field_name, field_info in six.iteritems(data_struct_dict):\n        field_type = field_info['type']\n        if field_type == DictField.FIELD_TYPE_NAME and isinstance(field_info.get('validator'), dict):\n            field_info['validator'] = create_validator(field_info['validator'])\n        attrs[field_name] = create_field(field_info)\n    name = force_str(name)\n    return type(name, (Validator, ), attrs)"
    },
    {
        "code": "def get_branch_mutation_matrix(self, node, full_sequence=False):\n        pp,pc = self.marginal_branch_profile(node)\n        expQt = self.gtr.expQt(self._branch_length_to_gtr(node))\n        if len(expQt.shape)==3:\n            mut_matrix_stack = np.einsum('ai,aj,ija->aij', pc, pp, expQt)\n        else:\n            mut_matrix_stack = np.einsum('ai,aj,ij->aij', pc, pp, expQt)\n        normalizer = mut_matrix_stack.sum(axis=2).sum(axis=1)\n        mut_matrix_stack = np.einsum('aij,a->aij', mut_matrix_stack, 1.0/normalizer)\n        if full_sequence:\n            return mut_matrix_stack[self.full_to_reduced_sequence_map]\n        else:\n            return mut_matrix_stack"
    },
    {
        "code": "def get_window(window, Nx, fftbins=True):\n    if six.callable(window):\n        return window(Nx)\n    elif (isinstance(window, (six.string_types, tuple)) or\n          np.isscalar(window)):\n        return scipy.signal.get_window(window, Nx, fftbins=fftbins)\n    elif isinstance(window, (np.ndarray, list)):\n        if len(window) == Nx:\n            return np.asarray(window)\n        raise ParameterError('Window size mismatch: '\n                             '{:d} != {:d}'.format(len(window), Nx))\n    else:\n        raise ParameterError('Invalid window specification: {}'.format(window))"
    },
    {
        "code": "def convert_to_this_nbformat(nb, orig_version=2, orig_minor=0):\n    if orig_version == 1:\n        nb = v2.convert_to_this_nbformat(nb)\n        orig_version = 2\n    if orig_version == 2:\n        nb.nbformat = nbformat\n        nb.nbformat_minor = nbformat_minor\n        nb.orig_nbformat = 2\n        return nb\n    elif orig_version == 3:\n        if orig_minor != nbformat_minor:\n            nb.orig_nbformat_minor = orig_minor\n        nb.nbformat_minor = nbformat_minor\n        return nb\n    else:\n        raise ValueError('Cannot convert a notebook from v%s to v3' % orig_version)"
    },
    {
        "code": "def sync_folder(self, path, bucket):\n        bucket = self.conn.get_bucket(bucket)\n        local_files = self._get_local_files(path)\n        s3_files = self._get_s3_files(bucket)\n        for filename, hash in local_files.iteritems():\n            s3_key = s3_files[filename]\n            if s3_key is None:\n                s3_key = Key(bucket)\n                s3_key.key = filename\n                s3_key.etag = '\"!\"'\n            if s3_key.etag[1:-1] != hash[0]:\n                s3_key.set_contents_from_filename(join(path, filename), md5=hash)"
    },
    {
        "code": "def wrap_class(cls, error_threshold=None):\n    methods = inspect.getmembers(cls, inspect.ismethod) + inspect.getmembers(cls, inspect.isfunction)\n    for method_name, method in methods:\n        wrapped_method = flawless.client.client._wrap_function_with_error_decorator(\n            method if not im_self(method) else im_func(method),\n            save_current_stack_trace=False,\n            error_threshold=error_threshold,\n        )\n        if im_self(method):\n            wrapped_method = classmethod(wrapped_method)\n        setattr(cls, method_name, wrapped_method)\n    return cls"
    },
    {
        "code": "def check_type(self, value, attr, data):\n        root_value = super(InstructionParameter, self).check_type(\n            value, attr, data)\n        if is_collection(value):\n            _ = [super(InstructionParameter, self).check_type(item, attr, data)\n                 for item in value]\n        return root_value"
    },
    {
        "code": "def _batch_gather_with_broadcast(params, indices, axis):\n  leading_bcast_shape = tf.broadcast_dynamic_shape(\n      tf.shape(input=params)[:axis],\n      tf.shape(input=indices)[:-1])\n  params += tf.zeros(\n      tf.concat((leading_bcast_shape, tf.shape(input=params)[axis:]), axis=0),\n      dtype=params.dtype)\n  indices += tf.zeros(\n      tf.concat((leading_bcast_shape, tf.shape(input=indices)[-1:]), axis=0),\n      dtype=indices.dtype)\n  return tf.compat.v1.batch_gather(params, indices)"
    },
    {
        "code": "def establish(self, call_id, timeout, limit=None,\n                  retry=None, max_retries=None):\n        rejected = 0\n        retried = 0\n        results = []\n        result_queue = self.result_queues[call_id]\n        try:\n            with Timeout(timeout, False):\n                while True:\n                    result = result_queue.get()\n                    if result is None:\n                        rejected += 1\n                        if retry is not None:\n                            if retried == max_retries:\n                                break\n                            retry()\n                            retried += 1\n                        continue\n                    results.append(result)\n                    if len(results) == limit:\n                        break\n        finally:\n            del result_queue\n            self.remove_result_queue(call_id)\n        if not results:\n            if rejected:\n                raise Rejected('%d workers rejected' % rejected\n                               if rejected != 1 else\n                               'A worker rejected')\n            else:\n                raise WorkerNotFound('failed to find worker')\n        return results"
    },
    {
        "code": "def slicify(slc, dim):\n    if isinstance(slc, slice):\n        start = 0 if slc.start is None else slc.start\n        stop = dim if slc.stop is None else slc.stop\n        step = 1 if slc.step is None else slc.step\n        if start < 0: start += dim\n        if stop < 0: stop += dim\n        if step > 0:\n            if start < 0: start = 0\n            if stop > dim: stop = dim\n        else:\n            if stop < 0: stop = -1\n            if start > dim: start = dim-1\n        return slice(start, stop, step)\n    elif isinstance(slc, int):\n        if slc < 0:\n            slc += dim\n        return slice(slc, slc+1, 1)\n    else:\n        raise ValueError(\"Type for slice %s not recongized\" % type(slc))"
    },
    {
        "code": "def enable_gtk(self, app=None):\n        import gtk\n        try:\n            gtk.set_interactive(True)\n            self._current_gui = GUI_GTK\n        except AttributeError:\n            from IPython.lib.inputhookgtk import inputhook_gtk\n            self.set_inputhook(inputhook_gtk)\n            self._current_gui = GUI_GTK"
    },
    {
        "code": "def overlapping(self, variant_obj):\n        category = 'snv' if variant_obj['category'] == 'sv' else 'sv'\n        query = {\n            '$and': [\n                {'case_id': variant_obj['case_id']},\n                {'category': category},\n                {'hgnc_ids' : { '$in' : variant_obj['hgnc_ids']}}\n            ]\n        }\n        sort_key = [('rank_score', pymongo.DESCENDING)]\n        variants = self.variant_collection.find(query).sort(sort_key).limit(30)\n        return variants"
    },
    {
        "code": "def convert_camel_case(name):\n    s1 = re.sub('(.)([A-Z][a-z]+)', r'\\1_\\2', name)\n    return re.sub('([a-z0-9])([A-Z])', r'\\1_\\2', s1).lower()"
    },
    {
        "code": "def incpos(self, length: int=1) -> int:\n        if length < 0:\n            raise ValueError(\"length must be positive\")\n        i = 0\n        while (i < length):\n            if self._cursor.index < self._len:\n                if self.peek_char == '\\n':\n                    self._cursor.step_next_line()\n                self._cursor.step_next_char()\n            i += 1\n        return self._cursor.index"
    },
    {
        "code": "def cache(func):\n    CACHE_DIR = appdirs.user_cache_dir('sportsref', getpass.getuser())\n    if not os.path.isdir(CACHE_DIR):\n        os.makedirs(CACHE_DIR)\n    @funcutils.wraps(func)\n    def wrapper(url):\n        file_hash = hashlib.md5()\n        encoded_url = url.encode(errors='replace')\n        file_hash.update(encoded_url)\n        file_hash = file_hash.hexdigest()\n        filename = '{}/{}'.format(CACHE_DIR, file_hash)\n        sport_id = None\n        for a_base_url, a_sport_id in sportsref.SITE_ABBREV.items():\n            if url.startswith(a_base_url):\n                sport_id = a_sport_id\n                break\n        else:\n            print('No sport ID found for {}, not able to check cache'.format(url))\n        file_exists = os.path.isfile(filename)\n        if sport_id and file_exists:\n            cur_time = int(time.time())\n            mod_time = int(os.path.getmtime(filename))\n            days_since_mod = datetime.timedelta(seconds=(cur_time - mod_time)).days\n            days_cache_valid = globals()['_days_valid_{}'.format(sport_id)](url)\n            cache_is_valid = days_since_mod < days_cache_valid\n        else:\n            cache_is_valid = False\n        allow_caching = sportsref.get_option('cache')\n        if file_exists and cache_is_valid and allow_caching:\n            with codecs.open(filename, 'r', encoding='utf-8', errors='replace') as f:\n                text = f.read()\n        else:\n            text = func(url)\n            with codecs.open(filename, 'w+', encoding='utf-8') as f:\n                f.write(text)\n        return text\n    return wrapper"
    },
    {
        "code": "def onTWriteCallback__init(self, sim):\n        yield from self.onTWriteCallback(sim)\n        self.intf.t._sigInside.registerWriteCallback(\n            self.onTWriteCallback,\n            self.getEnable)\n        self.intf.o._sigInside.registerWriteCallback(\n            self.onTWriteCallback,\n            self.getEnable)"
    },
    {
        "code": "def delims(self, delims):\n        expr = '[' + ''.join('\\\\'+ c for c in delims) + ']'\n        self._delim_re = re.compile(expr)\n        self._delims = delims\n        self._delim_expr = expr"
    },
    {
        "code": "def ALL_mentions(target_mentions, chain_mentions):\n    found_all = True\n    for name in target_mentions:\n        found_one = False\n        for chain_ment in chain_mentions:\n            if name in chain_ment:\n                found_one = True\n                break\n        if not found_one:\n            found_all = False\n            break\n    return found_all"
    },
    {
        "code": "def execute(self, obj):\n        try:\n            if self.config.stdin:\n                    self.spawn(self.config.command, stdin_content=obj, stdin=True, timeout=1)\n            else:\n                if \"@@\" not in self.config.command:\n                    raise PJFMissingArgument(\"Missing @@ filename indicator while using non-stdin fuzzing method\")\n                for x in self.config.command:\n                    if \"@@\" in x:\n                        self.config.command[self.config.command.index(x)] = x.replace(\"@@\", obj)\n                self.spawn(self.config.command, timeout=2)\n            self.logger.debug(\"[{0}] - PJFExternalFuzzer successfully completed\".format(time.strftime(\"%H:%M:%S\")))\n            return self._out\n        except KeyboardInterrupt:\n            return \"\"\n        except Exception as e:\n            raise PJFBaseException(e.message if hasattr(e, \"message\") else str(e))"
    },
    {
        "code": "def can_cut(self):\n        cursor = self._control.textCursor()\n        return (cursor.hasSelection() and\n                self._in_buffer(cursor.anchor()) and\n                self._in_buffer(cursor.position()))"
    },
    {
        "code": "def get_importer(path_item):\n    try:\n        importer = sys.path_importer_cache[path_item]\n    except KeyError:\n        for hook in sys.path_hooks:\n            try:\n                importer = hook(path_item)\n            except ImportError:\n                pass\n            else:\n                break\n        else:\n            importer = None\n    sys.path_importer_cache.setdefault(path_item,importer)\n    if importer is None:\n        try:\n            importer = ImpWrapper(path_item)\n        except ImportError:\n            pass\n    return importer"
    },
    {
        "code": "def create_resized_image(self, path_to_image, save_path_on_storage,\n                             width, height):\n        image, file_ext, image_format, mime_type = self.retrieve_image(\n            path_to_image\n        )\n        image, save_kwargs = self.preprocess(image, image_format)\n        imagefile = self.process_image(\n            image=image,\n            image_format=image_format,\n            save_kwargs=save_kwargs,\n            width=width,\n            height=height\n        )\n        self.save_image(imagefile, save_path_on_storage, file_ext, mime_type)"
    },
    {
        "code": "def predict_on_stream(config: Union[str, Path, dict], batch_size: int = 1, file_path: Optional[str] = None) -> None:\n    if file_path is None or file_path == '-':\n        if sys.stdin.isatty():\n            raise RuntimeError('To process data from terminal please use interact mode')\n        f = sys.stdin\n    else:\n        f = open(file_path, encoding='utf8')\n    model: Chainer = build_model(config)\n    args_count = len(model.in_x)\n    while True:\n        batch = list((l.strip() for l in islice(f, batch_size * args_count)))\n        if not batch:\n            break\n        args = []\n        for i in range(args_count):\n            args.append(batch[i::args_count])\n        res = model(*args)\n        if len(model.out_params) == 1:\n            res = [res]\n        for res in zip(*res):\n            res = json.dumps(res, ensure_ascii=False)\n            print(res, flush=True)\n    if f is not sys.stdin:\n        f.close()"
    },
    {
        "code": "def paths(input_dir):\n    'yield all file paths under input_dir'\n    for root, dirs, fnames in os.walk(input_dir):\n        for i_fname in fnames:\n            i_path = os.path.join(root, i_fname)\n            yield i_path"
    },
    {
        "code": "def evaluate_min_coverage(coverage_opt, assembly_coverage, assembly_size):\n    if coverage_opt == \"auto\":\n        min_coverage = (assembly_coverage / assembly_size) * .3\n        logger.info(\"Minimum assembly coverage automatically set to: \"\n                    \"{}\".format(min_coverage))\n        if min_coverage < 10:\n            logger.info(\"Minimum assembly coverage cannot be set to lower\"\n                        \" that 10. Setting to 10\")\n            min_coverage = 10\n    else:\n        min_coverage = int(coverage_opt)\n        logger.info(\"Minimum assembly coverage manually set to: {}\".format(\n            min_coverage))\n    return min_coverage"
    },
    {
        "code": "def dbgr(self, string):\n        print('')\n        self.proc.cmd_queue.append(string)\n        self.proc.process_command()\n        return"
    },
    {
        "code": "def register(self, contract):\n        \"registers NativeContract classes\"\n        assert issubclass(contract, NativeContractBase)\n        assert len(contract.address) == 20\n        assert contract.address.startswith(self.native_contract_address_prefix)\n        if self.native_contracts.get(contract.address) == contract._on_msg:\n            log.debug(\"already registered\", contract=contract, address=contract.address)\n            return\n        assert contract.address not in self.native_contracts, 'address already taken'\n        self.native_contracts[contract.address] = contract._on_msg\n        log.debug(\"registered native contract\", contract=contract, address=contract.address)"
    },
    {
        "code": "def assert_no_title(self, title, **kwargs):\n        query = TitleQuery(title, **kwargs)\n        @self.synchronize(wait=query.wait)\n        def assert_no_title():\n            if query.resolves_for(self):\n                raise ExpectationNotMet(query.negative_failure_message)\n            return True\n        return assert_no_title()"
    },
    {
        "code": "def IsNotNone(*fields, default=None):\n    when_clauses = [\n        expressions.When(\n            ~expressions.Q(**{field: None}),\n            then=expressions.F(field)\n        )\n        for field in reversed(fields)\n    ]\n    return expressions.Case(\n        *when_clauses,\n        default=expressions.Value(default),\n        output_field=CharField()\n    )"
    },
    {
        "code": "def jenkins_request_with_headers(jenkins_server, req):\n    try:\n        response = jenkins_server.jenkins_request(req)\n        response_body = response.content\n        response_headers = response.headers\n        if response_body is None:\n            raise jenkins.EmptyResponseException(\n                \"Error communicating with server[%s]: \"\n                \"empty response\" % jenkins_server.server)\n        return {'body': response_body.decode('utf-8'), 'headers': response_headers}\n    except HTTPError as e:\n        if e.code in [401, 403, 500]:\n            raise JenkinsException(\n                'Error in request. ' +\n                'Possibly authentication failed [%s]: %s' % (\n                    e.code, e.msg)\n            )\n        elif e.code == 404:\n            raise jenkins.NotFoundException('Requested item could not be found')\n        else:\n            raise\n    except socket.timeout as e:\n        raise jenkins.TimeoutException('Error in request: %s' % e)\n    except URLError as e:\n        if str(e.reason) == \"timed out\":\n            raise jenkins.TimeoutException('Error in request: %s' % e.reason)\n        raise JenkinsException('Error in request: %s' % e.reason)"
    },
    {
        "code": "def _left_doubling_increments(batch_shape, max_doublings, step_size, seed=None,\n                              name=None):\n  with tf.compat.v1.name_scope(name, 'left_doubling_increments',\n                               [batch_shape, max_doublings, step_size]):\n    step_size = tf.convert_to_tensor(value=step_size)\n    dtype = step_size.dtype.base_dtype\n    output_shape = tf.concat(([max_doublings + 1], batch_shape), axis=0)\n    expand_left = distributions.Bernoulli(0.5, dtype=dtype).sample(\n        sample_shape=output_shape, seed=seed)\n    width_multipliers = tf.cast(2 ** tf.range(0, max_doublings+1), dtype=dtype)\n    widths_shape = tf.concat(([max_doublings + 1],\n                              tf.ones_like(batch_shape)), axis=0)\n    width_multipliers = tf.reshape(width_multipliers, shape=widths_shape)\n    widths = width_multipliers * step_size\n    left_increments = tf.cumsum(widths * expand_left, exclusive=True, axis=0)\n    return left_increments, widths"
    },
    {
        "code": "def _joint_sample_n(self, n, seed=None):\n    with tf.name_scope(\"sample_n_joint\"):\n      stream = seed_stream.SeedStream(\n          seed, salt=\"LinearGaussianStateSpaceModel_sample_n_joint\")\n      sample_and_batch_shape = distribution_util.prefer_static_value(\n          tf.concat([[n], self.batch_shape_tensor()],\n                    axis=0))\n      with tf.control_dependencies(self.runtime_assertions):\n        initial_latent = self.initial_state_prior.sample(\n            sample_shape=_augment_sample_shape(\n                self.initial_state_prior,\n                sample_and_batch_shape,\n                self.validate_args),\n            seed=stream())\n        initial_latent = initial_latent[..., tf.newaxis]\n      initial_observation_matrix = (\n          self.get_observation_matrix_for_timestep(self.initial_step))\n      initial_observation_noise = (\n          self.get_observation_noise_for_timestep(self.initial_step))\n      initial_observation_pred = initial_observation_matrix.matmul(\n          initial_latent)\n      initial_observation = (initial_observation_pred +\n                             initial_observation_noise.sample(\n                                 sample_shape=_augment_sample_shape(\n                                     initial_observation_noise,\n                                     sample_and_batch_shape,\n                                     self.validate_args),\n                                 seed=stream())[..., tf.newaxis])\n      sample_step = build_kalman_sample_step(\n          self.get_transition_matrix_for_timestep,\n          self.get_transition_noise_for_timestep,\n          self.get_observation_matrix_for_timestep,\n          self.get_observation_noise_for_timestep,\n          full_sample_and_batch_shape=sample_and_batch_shape,\n          stream=stream,\n          validate_args=self.validate_args)\n      (latents, observations) = tf.scan(\n          sample_step,\n          elems=tf.range(self.initial_step+1, self.final_step),\n          initializer=(initial_latent, initial_observation))\n      latents = tf.concat([initial_latent[tf.newaxis, ...],\n                           latents], axis=0)\n      observations = tf.concat([initial_observation[tf.newaxis, ...],\n                                observations], axis=0)\n      latents = tf.squeeze(latents, -1)\n      latents = distribution_util.move_dimension(latents, 0, -2)\n      observations = tf.squeeze(observations, -1)\n      observations = distribution_util.move_dimension(observations, 0, -2)\n    return latents, observations"
    },
    {
        "code": "def simple_attention(memory, att_size, mask, keep_prob=1.0, scope=\"simple_attention\"):\n    with tf.variable_scope(scope):\n        BS, ML, MH = tf.unstack(tf.shape(memory))\n        memory_do = tf.nn.dropout(memory, keep_prob=keep_prob, noise_shape=[BS, 1, MH])\n        logits = tf.layers.dense(tf.layers.dense(memory_do, att_size, activation=tf.nn.tanh), 1, use_bias=False)\n        logits = softmax_mask(tf.squeeze(logits, [2]), mask)\n        att_weights = tf.expand_dims(tf.nn.softmax(logits), axis=2)\n        res = tf.reduce_sum(att_weights * memory, axis=1)\n        return res"
    },
    {
        "code": "def _dump_text(self):\n        results = self._relay_output['result'];\n        for l in results:\n            dt = time.strftime(\"%Y-%m-%dT%H:%M:%SZ\", time.gmtime(int(l[1]['ts'])))\n            print(\"{0} {1} {2} {3}\".format(l[0], dt, l[1]['type'], l[1]['msg']))"
    },
    {
        "code": "def get_ip_address_info(ip_address, cache=None, nameservers=None,\n                        timeout=2.0, parallel=False):\n    ip_address = ip_address.lower()\n    if cache:\n        info = cache.get(ip_address, None)\n        if info:\n            return info\n    info = OrderedDict()\n    info[\"ip_address\"] = ip_address\n    reverse_dns = get_reverse_dns(ip_address,\n                                  nameservers=nameservers,\n                                  timeout=timeout)\n    country = get_ip_address_country(ip_address, parallel=parallel)\n    info[\"country\"] = country\n    info[\"reverse_dns\"] = reverse_dns\n    info[\"base_domain\"] = None\n    if reverse_dns is not None:\n        base_domain = get_base_domain(reverse_dns)\n        info[\"base_domain\"] = base_domain\n    return info"
    },
    {
        "code": "def _explore(self, explore_iterable):\n        if self.v_locked:\n            raise pex.ParameterLockedException('Parameter `%s` is locked!' % self.v_full_name)\n        if self.f_has_range():\n            raise TypeError('Your parameter `%s` is already explored, '\n                            'cannot _explore it further!' % self._name)\n        if self._data is None:\n            raise TypeError('Your parameter `%s` has no default value, please specify one '\n                            'via `f_set` before exploration. ' % self.v_full_name)\n        data_list = self._data_sanity_checks(explore_iterable)\n        self._explored_range = data_list\n        self._explored = True\n        self.f_lock()"
    },
    {
        "code": "async def fetch(self) -> Response:\n        if self.request_config.get('DELAY', 0) > 0:\n            await asyncio.sleep(self.request_config['DELAY'])\n        timeout = self.request_config.get('TIMEOUT', 10)\n        try:\n            async with async_timeout.timeout(timeout):\n                resp = await self._make_request()\n            try:\n                resp_data = await resp.text(encoding=self.encoding)\n            except UnicodeDecodeError:\n                resp_data = await resp.read()\n            response = Response(\n                url=self.url,\n                method=self.method,\n                encoding=resp.get_encoding(),\n                html=resp_data,\n                metadata=self.metadata,\n                cookies=resp.cookies,\n                headers=resp.headers,\n                history=resp.history,\n                status=resp.status,\n                aws_json=resp.json,\n                aws_text=resp.text,\n                aws_read=resp.read)\n            aws_valid_response = self.request_config.get('VALID')\n            if aws_valid_response and iscoroutinefunction(aws_valid_response):\n                response = await aws_valid_response(response)\n            if response.ok:\n                return response\n            else:\n                return await self._retry(error_msg='request url failed!')\n        except asyncio.TimeoutError:\n            return await self._retry(error_msg='timeout')\n        except Exception as e:\n            return await self._retry(error_msg=e)\n        finally:\n            await self._close_request_session()"
    },
    {
        "code": "def _prm_read_dictionary(self, leaf, full_name):\n        try:\n            temp_table = self._prm_read_table(leaf, full_name)\n            temp_dict = temp_table.to_dict('list')\n            innder_dict = {}\n            for innerkey, vallist in temp_dict.items():\n                innder_dict[innerkey] = vallist[0]\n            return innder_dict\n        except:\n            self._logger.error('Failed loading `%s` of `%s`.' % (leaf._v_name, full_name))\n            raise"
    },
    {
        "code": "def _validate_value(key, value, expected_type):\n    if not isinstance(value, expected_type):\n        raise TypeError(\"{} argument must have a type {} not {}\".format(\n            key, expected_type, type(value)))"
    },
    {
        "code": "def unified_file(self):\n        if (\n            \"file_to_test\" in PyFunceble.INTERN\n            and PyFunceble.INTERN[\"file_to_test\"]\n            and PyFunceble.CONFIGURATION[\"unified\"]\n        ):\n            output = (\n                self.output_parent_dir + PyFunceble.OUTPUTS[\"default_files\"][\"results\"]\n            )\n            if PyFunceble.CONFIGURATION[\"less\"]:\n                if PyFunceble.HTTP_CODE[\"active\"]:\n                    to_print = [\n                        self.tested,\n                        self.domain_status,\n                        PyFunceble.INTERN[\"http_code\"],\n                    ]\n                else:\n                    to_print = [self.tested, self.domain_status, self.source]\n                Prints(to_print, \"Less\", output, True).data()\n            else:\n                to_print = [\n                    self.tested,\n                    self.domain_status,\n                    self.expiration_date,\n                    self.source,\n                    PyFunceble.INTERN[\"http_code\"],\n                    PyFunceble.CURRENT_TIME,\n                ]\n                Prints(to_print, \"Generic_File\", output, True).data()"
    },
    {
        "code": "def print_table(language):\n    table = translation_table(language)\n    for code, name in sorted(table.items(), key=operator.itemgetter(0)):\n        print(u'{language:<8} {name:\\u3000<20}'.format(\n            name=name, language=code\n        ))\n    return None"
    },
    {
        "code": "def yzy_to_zyz(xi, theta1, theta2, eps=1e-9):\n        quaternion_yzy = quaternion_from_euler([theta1, xi, theta2], 'yzy')\n        euler = quaternion_yzy.to_zyz()\n        quaternion_zyz = quaternion_from_euler(euler, 'zyz')\n        out_angles = (euler[1], euler[0], euler[2])\n        abs_inner = abs(quaternion_zyz.data.dot(quaternion_yzy.data))\n        if not np.allclose(abs_inner, 1, eps):\n            raise TranspilerError('YZY and ZYZ angles do not give same rotation matrix.')\n        out_angles = tuple(0 if np.abs(angle) < _CHOP_THRESHOLD else angle\n                           for angle in out_angles)\n        return out_angles"
    },
    {
        "code": "def select_lasso(self, expression_x, expression_y, xsequence, ysequence, mode=\"replace\", name=\"default\", executor=None):\n        def create(current):\n            return selections.SelectionLasso(expression_x, expression_y, xsequence, ysequence, current, mode)\n        self._selection(create, name, executor=executor)"
    },
    {
        "code": "def resize_to(self, width, height):\n        self.driver.resize_window_to(self.handle, width, height)"
    },
    {
        "code": "def merge(self, new_dict):\n        actions = new_dict.pop(\"actions\")\n        for action in actions:\n            self.add_action(action)\n        self.__dict__.update(new_dict)"
    },
    {
        "code": "def _run_writers(self, start_count, next_idx, sources, i_str, t_path):\n        name_info = dict(\n            first=start_count,\n            source=sources.pop(),\n            )\n        all_o_paths = []\n        for writer in self.writers:\n            logger.debug('running %r on %r: %r', writer, i_str, name_info)\n            o_paths = writer(t_path, name_info, i_str)\n            logger.debug('loaded (%d, %d) of %r into %r',\n                         start_count, next_idx - 1, i_str, o_paths)\n            all_o_paths += o_paths\n        return all_o_paths"
    },
    {
        "code": "def _height_is_big_enough(image, height):\n    if height > image.size[1]:\n        raise ImageSizeError(image.size[1], height)"
    },
    {
        "code": "def add_enrichr_parser(subparsers):\n    argparser_enrichr = subparsers.add_parser(\"enrichr\", help=\"Using Enrichr API to perform GO analysis.\")\n    enrichr_opt = argparser_enrichr.add_argument_group(\"Input arguments\")\n    enrichr_opt.add_argument(\"-i\", \"--input-list\", action=\"store\", dest=\"gene_list\", type=str, required=True, metavar='IDs',\n                              help=\"Enrichr uses a list of gene names as input.\")\n    enrichr_opt.add_argument(\"-g\", \"--gene-sets\", action=\"store\", dest=\"library\", type=str, required=True, metavar='GMT',\n                              help=\"Enrichr library name(s) required. Separate each name by comma.\")\n    enrichr_opt.add_argument(\"--org\", \"--organism\", action=\"store\", dest=\"organism\", type=str, default='',\n                             help=\"Enrichr supported organism name. Default: human. See here: https://amp.pharm.mssm.edu/modEnrichr.\")\n    enrichr_opt.add_argument(\"--ds\", \"--description\", action=\"store\", dest=\"descrip\", type=str, default='enrichr', metavar='STRING',\n                              help=\"It is recommended to enter a short description for your list so that multiple lists \\\n                              can be differentiated from each other if you choose to save or share your list.\")\n    enrichr_opt.add_argument(\"--cut\", \"--cut-off\", action=\"store\", dest=\"thresh\", metavar='float', type=float, default=0.05,\n                              help=\"Adjust-Pval cutoff, used for generating plots. Default: 0.05.\")\n    enrichr_opt.add_argument(\"--bg\", \"--background\", action=\"store\", dest=\"bg\", default='hsapiens_gene_ensembl', metavar='BGNUM',\n                              help=\"BioMart Dataset name or Background total genes number. Default: None\")\n    enrichr_opt.add_argument(\"-t\", \"--top-term\", dest=\"term\", action=\"store\", type=int, default=10, metavar='int',\n                              help=\"Numbers of top terms shown in the plot. Default: 10\")\n    enrichr_output = argparser_enrichr.add_argument_group(\"Output figure arguments\")\n    add_output_option(enrichr_output)\n    return"
    },
    {
        "code": "def strval(node, outermost=True):\n    if not isinstance(node, element):\n        return node.xml_value if outermost else [node.xml_value]\n    accumulator = []\n    for child in node.xml_children:\n        if isinstance(child, text):\n            accumulator.append(child.xml_value)\n        elif isinstance(child, element):\n            accumulator.extend(strval(child, outermost=False))\n    if outermost: accumulator = ''.join(accumulator)\n    return accumulator"
    },
    {
        "code": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):\n        local_stream = utils.BytearrayStream()\n        if self._unique_identifier:\n            self._unique_identifier.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._usage_limits_count:\n            self._usage_limits_count.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._cryptographic_usage_mask:\n            self._cryptographic_usage_mask.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        if self._lease_time:\n            self._lease_time.write(\n                local_stream,\n                kmip_version=kmip_version\n            )\n        self.length = local_stream.length()\n        super(CheckResponsePayload, self).write(\n            output_stream,\n            kmip_version=kmip_version\n        )\n        output_stream.write(local_stream.buffer)"
    },
    {
        "code": "def apply_operation_back(self, op, qargs=None, cargs=None, condition=None):\n        qargs = qargs or []\n        cargs = cargs or []\n        all_cbits = self._bits_in_condition(condition)\n        all_cbits.extend(cargs)\n        self._check_condition(op.name, condition)\n        self._check_bits(qargs, self.output_map)\n        self._check_bits(all_cbits, self.output_map)\n        self._add_op_node(op, qargs, cargs, condition)\n        al = [qargs, all_cbits]\n        for q in itertools.chain(*al):\n            ie = list(self._multi_graph.predecessors(self.output_map[q]))\n            if len(ie) != 1:\n                raise DAGCircuitError(\"output node has multiple in-edges\")\n            self._multi_graph.add_edge(ie[0], self._id_to_node[self._max_node_id],\n                                       name=\"%s[%s]\" % (q[0].name, q[1]), wire=q)\n            self._multi_graph.remove_edge(ie[0], self.output_map[q])\n            self._multi_graph.add_edge(self._id_to_node[self._max_node_id], self.output_map[q],\n                                       name=\"%s[%s]\" % (q[0].name, q[1]), wire=q)\n        return self._id_to_node[self._max_node_id]"
    },
    {
        "code": "def configure(self, options, config):\n        log.debug(\"Configuring plugins\")\n        self.config = config\n        cfg = PluginProxy('configure', self._plugins)\n        cfg(options, config)\n        enabled = [plug for plug in self._plugins if plug.enabled]\n        self.plugins = enabled\n        self.sort()\n        log.debug(\"Plugins enabled: %s\", enabled)"
    },
    {
        "code": "def s2n(self):\n        M_N = 8.0713171\n        f = lambda parent, daugther: -parent + daugther + 2 * M_N\n        return self.derived('s2n', (0, -2), f)"
    },
    {
        "code": "async def wait_changed(self):\n        if not self.is_complete():\n            waiter = self._loop.create_future()\n            self._waiters.append(waiter)\n            await waiter"
    },
    {
        "code": "def add_virtual_columns_proper_motion2vperpendicular(self, distance=\"distance\", pm_long=\"pm_l\", pm_lat=\"pm_b\",\n                                                     vl=\"vl\", vb=\"vb\",\n                                                     propagate_uncertainties=False,\n                                                     radians=False):\n    k = 4.74057\n    self.add_variable(\"k\", k, overwrite=False)\n    self.add_virtual_column(vl, \"k*{pm_long}*{distance}\".format(**locals()))\n    self.add_virtual_column(vb, \"k* {pm_lat}*{distance}\".format(**locals()))\n    if propagate_uncertainties:\n        self.propagate_uncertainties([self[vl], self[vb]])"
    },
    {
        "code": "def _build_trainable_posterior(param, initial_loc_fn):\n  loc = tf.compat.v1.get_variable(\n      param.name + '_loc',\n      initializer=lambda: initial_loc_fn(param),\n      dtype=param.prior.dtype,\n      use_resource=True)\n  scale = tf.nn.softplus(\n      tf.compat.v1.get_variable(\n          param.name + '_scale',\n          initializer=lambda: -4 * tf.ones_like(initial_loc_fn(param)),\n          dtype=param.prior.dtype,\n          use_resource=True))\n  q = tfd.Normal(loc=loc, scale=scale)\n  if (param.prior.event_shape.ndims is None\n      or param.prior.event_shape.ndims > 0):\n    q = tfd.Independent(\n        q, reinterpreted_batch_ndims=param.prior.event_shape.ndims)\n  return tfd.TransformedDistribution(q, param.bijector)"
    },
    {
        "code": "def poll(self):\n        service = yield self.get_service()\n        if not service:\n            self.log.warn(\"Docker service not found\")\n            return 0\n        task_filter = {'service': service['Spec']['Name']}\n        tasks = yield self.docker(\n            'tasks', task_filter\n        )\n        running_task = None\n        for task in tasks:\n            task_state = task['Status']['State']\n            self.log.debug(\n                \"Task %s of Docker service %s status: %s\",\n                task['ID'][:7],\n                self.service_id[:7],\n                pformat(task_state),\n            )\n            if task_state == 'running':\n                running_task = task\n        if running_task is not None:\n            return None\n        else:\n            return 1"
    },
    {
        "code": "def var(self, axis=None, keepdims=False):\n        return self._stat(axis, name='variance', keepdims=keepdims)"
    },
    {
        "code": "def get_ids(self, features, threshold=0.0, func=np.sum, get_weights=False):\n        if isinstance(features, str):\n            features = [features]\n        features = self.search_features(features)\n        feature_weights = self.data.ix[:, features]\n        weights = feature_weights.apply(func, 1)\n        above_thresh = weights[weights >= threshold]\n        return above_thresh if get_weights else list(above_thresh.index)"
    },
    {
        "code": "def is_error(node: astroid.node_classes.NodeNG) -> bool:\n    for child_node in node.get_children():\n        if isinstance(child_node, astroid.Raise):\n            return True\n    return False"
    },
    {
        "code": "def _sentences(self, clean_visible):\n        'generate strings identified as sentences'\n        previous_end = 0\n        clean_visible = clean_visible.decode('utf8')\n        for start, end in self.sentence_tokenizer.span_tokenize(clean_visible):\n            if start < previous_end:\n                start = previous_end\n                if start > end:\n                    continue\n            try:\n                label = self.label_index.find_le(end)\n            except ValueError:\n                label = None\n            if label:\n                off = label.offsets[OffsetType.CHARS]\n                end = max(off.first + off.length, end)\n            previous_end = end\n            sent_str = clean_visible[start:end]\n            yield start, end, sent_str"
    },
    {
        "code": "def set_default_bg():\n    term = environ.get('TERM', None)\n    if term:\n        if (term.startswith('xterm',) or term.startswith('eterm')\n            or term == 'dtterm'):\n            return False\n    return True"
    },
    {
        "code": "def run(self, data_loaders, workflow, max_epochs, **kwargs):\n        assert isinstance(data_loaders, list)\n        assert mmcv.is_list_of(workflow, tuple)\n        assert len(data_loaders) == len(workflow)\n        self._max_epochs = max_epochs\n        work_dir = self.work_dir if self.work_dir is not None else 'NONE'\n        self.logger.info('Start running, host: %s, work_dir: %s',\n                         get_host_info(), work_dir)\n        self.logger.info('workflow: %s, max: %d epochs', workflow, max_epochs)\n        self.call_hook('before_run')\n        while self.epoch < max_epochs:\n            for i, flow in enumerate(workflow):\n                mode, epochs = flow\n                if isinstance(mode, str):\n                    if not hasattr(self, mode):\n                        raise ValueError(\n                            'runner has no method named \"{}\" to run an epoch'.\n                            format(mode))\n                    epoch_runner = getattr(self, mode)\n                elif callable(mode):\n                    epoch_runner = mode\n                else:\n                    raise TypeError('mode in workflow must be a str or '\n                                    'callable function, not {}'.format(\n                                        type(mode)))\n                for _ in range(epochs):\n                    if mode == 'train' and self.epoch >= max_epochs:\n                        return\n                    epoch_runner(data_loaders[i], **kwargs)\n        time.sleep(1)\n        self.call_hook('after_run')"
    },
    {
        "code": "def glance_process(body, message):\n    event_type = body['event_type']\n    process = glance_customer_process.get(event_type)\n    if process is not None:\n        process(body, message)\n    else:\n        matched = False\n        process_wildcard = None\n        for pattern in glance_customer_process_wildcard.keys():\n            if pattern.match(event_type):\n                process_wildcard = glance_customer_process_wildcard.get(pattern)\n                matched = True\n                break\n        if matched:\n            process_wildcard(body, message)\n        else:\n            default_process(body, message)\n    message.ack()"
    },
    {
        "code": "def pre_build(self, traj, brian_list, network_dict):\n        self._pre_build = not _explored_parameters_in_group(traj, traj.parameters.connections)\n        self._pre_build = (self._pre_build and 'neurons_i' in network_dict and\n                           'neurons_e' in network_dict)\n        if self._pre_build:\n            self._build_connections(traj, brian_list, network_dict)"
    },
    {
        "code": "def _create_idx_from_stream(self, stream):\n        stream_iter = iter(stream)\n        dimension = self.properties.dimension\n        darray = ctypes.c_double * dimension\n        mins = darray()\n        maxs = darray()\n        no_data = ctypes.cast(ctypes.pointer(ctypes.c_ubyte(0)),\n                              ctypes.POINTER(ctypes.c_ubyte))\n        def py_next_item(p_id, p_mins, p_maxs, p_dimension, p_data, p_length):\n            try:\n                p_id[0], coordinates, obj = next(stream_iter)\n            except StopIteration:\n                return -1\n            except Exception as exc:\n                self._exception = exc\n                return -1\n            if self.interleaved:\n                coordinates = Index.deinterleave(coordinates)\n            for i in range(dimension):\n                mins[i] = coordinates[i*2]\n                maxs[i] = coordinates[(i*2)+1]\n            p_mins[0] = ctypes.cast(mins, ctypes.POINTER(ctypes.c_double))\n            p_maxs[0] = ctypes.cast(maxs, ctypes.POINTER(ctypes.c_double))\n            p_dimension[0] = dimension\n            if obj is None:\n                p_data[0] = no_data\n                p_length[0] = 0\n            else:\n                p_length[0], data, _ = self._serialize(obj)\n                p_data[0] = ctypes.cast(data, ctypes.POINTER(ctypes.c_ubyte))\n            return 0\n        stream = core.NEXTFUNC(py_next_item)\n        return IndexStreamHandle(self.properties.handle, stream)"
    },
    {
        "code": "def isAcquired(self, lockID):\n        return self.__lockImpl.isAcquired(lockID, self.__selfID, time.time())"
    },
    {
        "code": "def fill_heatmap(self):\n        for module_path, lineno, runtime in self.lines_without_stdlib:\n            self._execution_count[module_path][lineno] += 1\n            self._heatmap[module_path][lineno] += runtime"
    },
    {
        "code": "def parse_unstruct(unstruct):\n    my_json = json.loads(unstruct)\n    data = my_json['data']\n    schema = data['schema']\n    if 'data' in data:\n        inner_data = data['data']\n    else:\n        raise SnowplowEventTransformationException([\"Could not extract inner data field from unstructured event\"])\n    fixed_schema = fix_schema(\"unstruct_event\", schema)\n    return [(fixed_schema, inner_data)]"
    },
    {
        "code": "def volume_percentage_used(self, volume):\r\n        volume = self._get_volume(volume)\r\n        if volume is not None:\r\n            total = int(volume[\"size\"][\"total\"])\r\n            used = int(volume[\"size\"][\"used\"])\r\n            if used is not None and used > 0 and \\\r\n               total is not None and total > 0:\r\n                return round((float(used) / float(total)) * 100.0, 1)"
    },
    {
        "code": "def _sample_3d(self, n, seed=None):\n    seed = seed_stream.SeedStream(seed, salt='von_mises_fisher_3d')\n    u_shape = tf.concat([[n], self._batch_shape_tensor()], axis=0)\n    z = tf.random.uniform(u_shape, seed=seed(), dtype=self.dtype)\n    safe_conc = tf.where(self.concentration > 0,\n                         self.concentration,\n                         tf.ones_like(self.concentration))\n    safe_z = tf.where(z > 0, z, tf.ones_like(z))\n    safe_u = 1 + tf.reduce_logsumexp(\n        input_tensor=[\n            tf.math.log(safe_z),\n            tf.math.log1p(-safe_z) - 2 * safe_conc\n        ],\n        axis=0) / safe_conc\n    u = tf.where(self.concentration > tf.zeros_like(safe_u), safe_u,\n                 2 * z - 1)\n    u = tf.where(tf.equal(z, 0), -tf.ones_like(u), u)\n    if not self._allow_nan_stats:\n      u = tf.debugging.check_numerics(u, 'u in _sample_3d')\n    return u[..., tf.newaxis]"
    },
    {
        "code": "def find_on_path(importer, path_item, only=False):\n    path_item = _normalize_cached(path_item)\n    if os.path.isdir(path_item) and os.access(path_item, os.R_OK):\n        if path_item.lower().endswith('.egg'):\n            yield Distribution.from_filename(\n                path_item, metadata=PathMetadata(\n                    path_item, os.path.join(path_item,'EGG-INFO')\n                )\n            )\n        else:\n            for entry in os.listdir(path_item):\n                lower = entry.lower()\n                if lower.endswith('.egg-info') or lower.endswith('.dist-info'):\n                    fullpath = os.path.join(path_item, entry)\n                    if os.path.isdir(fullpath):\n                        metadata = PathMetadata(path_item, fullpath)\n                    else:\n                        metadata = FileMetadata(fullpath)\n                    yield Distribution.from_location(\n                        path_item, entry, metadata, precedence=DEVELOP_DIST\n                    )\n                elif not only and lower.endswith('.egg'):\n                    dists = find_distributions(os.path.join(path_item, entry))\n                    for dist in dists:\n                        yield dist\n                elif not only and lower.endswith('.egg-link'):\n                    with open(os.path.join(path_item, entry)) as entry_file:\n                        entry_lines = entry_file.readlines()\n                    for line in entry_lines:\n                        if not line.strip():\n                            continue\n                        path = os.path.join(path_item, line.rstrip())\n                        dists = find_distributions(path)\n                        for item in dists:\n                            yield item\n                        break"
    },
    {
        "code": "def lists(self, pattern: str = None) -> List[WikiList]:\n        return [\n            lst for arg in self.arguments for lst in arg.lists(pattern) if lst]"
    },
    {
        "code": "def make_simple_step_size_update_policy(num_adaptation_steps,\n                                        target_rate=0.75,\n                                        decrement_multiplier=0.01,\n                                        increment_multiplier=0.01,\n                                        step_counter=None):\n  if step_counter is None and num_adaptation_steps is not None:\n    step_counter = tf.compat.v1.get_variable(\n        name='step_size_adaptation_step_counter',\n        initializer=np.array(-1, dtype=np.int32),\n        dtype=tf.int32,\n        trainable=False,\n        use_resource=True)\n  def step_size_simple_update_fn(step_size_var, kernel_results):\n    if kernel_results is None:\n      if mcmc_util.is_list_like(step_size_var):\n        return [tf.identity(ss) for ss in step_size_var]\n      return tf.identity(step_size_var)\n    log_n = tf.math.log(\n        tf.cast(\n            tf.size(input=kernel_results.log_accept_ratio),\n            kernel_results.log_accept_ratio.dtype))\n    log_mean_accept_ratio = tf.reduce_logsumexp(\n        input_tensor=tf.minimum(kernel_results.log_accept_ratio, 0.)) - log_n\n    adjustment = tf.where(\n        log_mean_accept_ratio < tf.cast(\n            tf.math.log(target_rate), log_mean_accept_ratio.dtype),\n        -decrement_multiplier / (1. + decrement_multiplier),\n        increment_multiplier)\n    def build_assign_op():\n      if mcmc_util.is_list_like(step_size_var):\n        return [\n            ss.assign_add(ss * tf.cast(adjustment, ss.dtype))\n            for ss in step_size_var\n        ]\n      return step_size_var.assign_add(\n          step_size_var * tf.cast(adjustment, step_size_var.dtype))\n    if num_adaptation_steps is None:\n      return build_assign_op()\n    else:\n      with tf.control_dependencies([step_counter.assign_add(1)]):\n        return tf.cond(\n            pred=step_counter < num_adaptation_steps,\n            true_fn=build_assign_op,\n            false_fn=lambda: step_size_var)\n  return step_size_simple_update_fn"
    },
    {
        "code": "def _update_status(self):\n        srun, scomp, sdead = self._s_running, self._s_completed, self._s_dead\n        running, completed, dead = self._running, self._completed, self._dead\n        for num, job in enumerate(running):\n            stat = job.stat_code\n            if stat == srun:\n                continue\n            elif stat == scomp:\n                completed.append(job)\n                self._comp_report.append(job)\n                running[num] = False\n            elif stat == sdead:\n                dead.append(job)\n                self._dead_report.append(job)\n                running[num] = False\n        running[:] = filter(None, running)"
    },
    {
        "code": "def headers_present(self, headers):\n        headers = {name: re.compile('(.*)') for name in headers}\n        self.add_matcher(matcher('HeadersMatcher', headers))"
    },
    {
        "code": "def download_csv(data, filename):\n    assert_is_type(data, H2OFrame)\n    assert_is_type(filename, str)\n    url = h2oconn.make_url(\"DownloadDataset\", 3) + \"?frame_id={}&hex_string=false\".format(data.frame_id)\n    with open(filename, \"wb\") as f:\n        f.write(urlopen()(url).read())"
    },
    {
        "code": "def _bind_parameter(self, parameter, value):\n        for (instr, param_index) in self._parameter_table[parameter]:\n            instr.params[param_index] = value"
    },
    {
        "code": "def exclude_downhole(filt, threshold=2):\n    cfilt = filt.copy()\n    inds = bool_2_indices(~filt)\n    rem = (np.diff(inds) >= threshold)[:, 0]\n    if any(rem):\n        if inds[rem].shape[0] > 1:\n            limit = inds[rem][1, 0]\n            cfilt[limit:] = False\n    return cfilt"
    },
    {
        "code": "def init_module(self, run_object):\n        self.profile = self.profile_module\n        self._run_object, _, self._run_args = run_object.partition(' ')\n        self._object_name = '%s (module)' % self._run_object\n        self._globs = {\n            '__file__': self._run_object,\n            '__name__': '__main__',\n            '__package__': None,\n        }\n        program_path = os.path.dirname(self._run_object)\n        if sys.path[0] != program_path:\n            sys.path.insert(0, program_path)\n        self._replace_sysargs()"
    },
    {
        "code": "def _main(self, fileobj, data, offset):\n        fileobj.seek(offset)\n        fileobj.write(data)"
    },
    {
        "code": "def encode(self, txt):\n        return list(self._fwd_index.get(c, 0) for c in txt)"
    },
    {
        "code": "def decrement(self):\n        with self._lock:\n            if self._count == 0:\n                raise RuntimeError(\n                    'Counter is at zero. It cannot dip below zero')\n            self._count -= 1\n            if self._is_finalized and self._count == 0:\n                self._callback()"
    },
    {
        "code": "def _initialize_slots(self, seed, hashvalues):\n        self.seed = seed\n        self.hashvalues = self._parse_hashvalues(hashvalues)"
    },
    {
        "code": "def get(self, *args, **kwargs):\n        if 'pk' in kwargs:\n            kwargs['parent'] = kwargs['pk']\n            kwargs['head'] = True\n            del kwargs['pk']\n        if 'request' in kwargs:\n\t       \trequest = kwargs['request']\n\t       \tversion = request.GET.get('version', None)\n\t       \tpreview_id = request.GET.get('preview_id', None)\n\t       \tif (version is not None) and (preview_id is not None):\n\t       \t\tkwargs['revision_id'] = version\n\t       \t\tkwargs['preview_id'] = preview_id\n\t       \t\tdel kwargs['is_published']\n\t       \tdel kwargs['request']\n        return super(PublishableManager, self).get(*args, **kwargs)"
    },
    {
        "code": "def withIndent(self, indent=1):\n        ctx = copy(self)\n        ctx.indent += indent\n        return ctx"
    },
    {
        "code": "def fix_header(filename, keyword, new_value):\n    hd = read_header(filename)\n    hi = read_header(filename, return_idxs=True)\n    idx = hi[keyword]\n    dtype = header_keyword_types[keyword]\n    dtype_to_type = {b'<l'  : np.int32,\n                     b'str' : bytes,\n                     b'<d'  : np.float64,\n                     b'angle' : to_sigproc_angle}\n    value_dtype = dtype_to_type[dtype]\n    if isinstance(value_dtype, bytes):\n        if len(hd[keyword]) == len(new_value):\n            val_str = np.int32(len(new_value)).tostring() + new_value\n        else:\n            raise RuntimeError(\"String size mismatch. Cannot update without rewriting entire file.\")\n    else:\n        val_str = value_dtype(new_value).tostring()\n    with open(filename, 'rb+') as fh:\n        fh.seek(idx)\n        fh.write(val_str)"
    },
    {
        "code": "def _match_one(self, rec, tests):\n        for key,test in tests.iteritems():\n            if not test(rec.get(key, None)):\n                return False\n        return True"
    },
    {
        "code": "def as_action_description(self):\n        description = {\n            self.name: {\n                'href': self.href_prefix + self.href,\n                'timeRequested': self.time_requested,\n                'status': self.status,\n            },\n        }\n        if self.input is not None:\n            description[self.name]['input'] = self.input\n        if self.time_completed is not None:\n            description[self.name]['timeCompleted'] = self.time_completed\n        return description"
    },
    {
        "code": "def parse(url):\n    config = {}\n    if not isinstance(url, six.string_types):\n        url = ''\n    url = urlparse.urlparse(url)\n    path = url.path[1:]\n    path = path.split('?', 2)[0]\n    config.update({\n        'NAME': path,\n        'USER': url.username,\n        'PASSWORD': url.password,\n        'HOST': url.hostname,\n        'PORT': url.port,\n    })\n    if url.scheme in SCHEMES:\n        config['ENGINE'] = SCHEMES[url.scheme]\n    return config"
    },
    {
        "code": "def get_table_content(self, table):\n        result = [[]]\n        cols = table.cols\n        for cell in self.compute_content(table):\n            if cols == 0:\n                result.append([])\n                cols = table.cols\n            cols -= 1\n            result[-1].append(cell)\n        while len(result[-1]) < cols:\n            result[-1].append(\"\")\n        return result"
    },
    {
        "code": "def connect(self):\n        SCOPES = 'https://www.googleapis.com/auth/drive'\n        store = file.Storage('drive_credentials.json')\n        creds = store.get()\n        if not creds or creds.invalid:\n            try:\n                flow = client.flow_from_clientsecrets('client_secret.json', SCOPES)\n            except InvalidClientSecretsError:\n                log.error('ERROR: Could not find client_secret.json in current directory, please obtain it from the API console.')\n                return\n            creds = tools.run_flow(flow, store)\n        self.connection = build('drive', 'v3', http=creds.authorize(Http()))\n        response = self.connection.files().list(q=\"name='Music' and mimeType='application/vnd.google-apps.folder' and trashed=false\").execute()\n        try:\n            folder_id = response.get('files', [])[0]['id']\n        except IndexError:\n            log.warning('Music folder is missing. Creating it.')\n            folder_metadata = {'name': 'Music', 'mimeType': 'application/vnd.google-apps.folder'}\n            folder = self.connection.files().create(body=folder_metadata, fields='id').execute()"
    },
    {
        "code": "def get_type(self, type_name):\n        type_name = self._canonicalize_type(type_name)\n        if str(type_name) == 'int':\n            type_name = 'integer'\n        elif str(type_name) == 'str':\n            type_name = 'string'\n        elif str(type_name) == 'dict':\n            type_name = 'basic_dict'\n        if self.is_known_type(type_name):\n            return self.known_types[type_name]\n        base_type, is_complex, subtypes = self.split_type(type_name)\n        if is_complex and base_type in self.type_factories:\n            self.instantiate_type(type_name, base_type, subtypes)\n            return self.known_types[type_name]\n        i = 0\n        for i, (source, name) in enumerate(self._lazy_type_sources):\n            if isinstance(source, str):\n                import pkg_resources\n                for entry in pkg_resources.iter_entry_points(source):\n                    try:\n                        mod = entry.load()\n                        type_system.load_type_module(mod)\n                    except:\n                        fail_info = (\"Entry point group: %s, name: %s\" % (source, entry.name), sys.exc_info)\n                        logging.exception(\"Error loading external type source from entry point, group: %s, name: %s\", source, entry.name)\n                        self.failed_sources.append(fail_info)\n            else:\n                try:\n                    source(self)\n                except:\n                    fail_info = (\"source: %s\" % name, sys.exc_info)\n                    logging.exception(\"Error loading external type source, source: %s\", source)\n                    self.failed_sources.append(fail_info)\n            if self.is_known_type(type_name) or (is_complex and base_type in self.type_factories):\n                break\n        self._lazy_type_sources = self._lazy_type_sources[i:]\n        if not (self.is_known_type(type_name) or (is_complex and base_type in self.type_factories)):\n            raise ArgumentError(\"get_type called on unknown type\", type=type_name, failed_external_sources=[x[0] for x in self.failed_sources])\n        return self.get_type(type_name)"
    },
    {
        "code": "def create(self):\n        if self.dirname and not os.path.exists(self.dirname):\n            os.makedirs(self.dirname)"
    },
    {
        "code": "def add_server(self, hostname, port, use_ssl, tls_ctx=None):\n        if not use_ssl and tls_ctx:\n            raise ValueError(\"Cannot specify a TLS context and not use SSL!\")\n        server = ldap3.Server(\n            hostname,\n            port=port,\n            use_ssl=use_ssl,\n            tls=tls_ctx\n        )\n        self._server_pool.add(server)\n        return server"
    },
    {
        "code": "def get_ref_annotation_data_after_time(self, id_tier, time):\n        befores = self.get_ref_annotation_data_between_times(\n            id_tier, time, self.get_full_time_interval())\n        if befores:\n            return [min(befores, key=lambda x: x[0])]\n        else:\n            return []"
    },
    {
        "code": "def import_data(\n            self, resource_group_name, name, files, format=None, custom_headers=None, raw=False, polling=True, **operation_config):\n        raw_result = self._import_data_initial(\n            resource_group_name=resource_group_name,\n            name=name,\n            files=files,\n            format=format,\n            custom_headers=custom_headers,\n            raw=True,\n            **operation_config\n        )\n        def get_long_running_output(response):\n            if raw:\n                client_raw_response = ClientRawResponse(None, response)\n                return client_raw_response\n        lro_delay = operation_config.get(\n            'long_running_operation_timeout',\n            self.config.long_running_operation_timeout)\n        if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)\n        elif polling is False: polling_method = NoPolling()\n        else: polling_method = polling\n        return LROPoller(self._client, raw_result, get_long_running_output, polling_method)"
    },
    {
        "code": "def flowshow(flow, win_name='', wait_time=0):\n    flow = flowread(flow)\n    flow_img = flow2rgb(flow)\n    imshow(rgb2bgr(flow_img), win_name, wait_time)"
    },
    {
        "code": "def duplicate(self, new_parent=None):\r\n        \"Create a new object exactly similar to self\"\r\n        kwargs = {}\r\n        for spec_name, spec in self._meta.specs.items():\r\n            value = getattr(self, spec_name)\r\n            if isinstance(value, Color):\r\n                print \"COLOR\", value, value.default\r\n                if value.default:\r\n                    value = None\r\n            if value is not None:\r\n                kwargs[spec_name] = value\r\n        del kwargs['parent'] \r\n        new_id = wx.NewId()\r\n        kwargs['id'] = new_id\r\n        kwargs['name'] = \"%s_%s\" % (kwargs['name'], new_id)\r\n        new_obj = self.__class__(new_parent or self.get_parent(), **kwargs)\r\n        for child in self:\r\n            child.duplicate(new_obj)\r\n        return new_obj"
    },
    {
        "code": "def option_attrname(self, opt, optdict=None):\n        if optdict is None:\n            optdict = self.get_option_def(opt)\n        return optdict.get(\"dest\", opt.replace(\"-\", \"_\"))"
    },
    {
        "code": "def set_issuer(self, issuer):\n        self._set_name(_lib.X509_set_issuer_name, issuer)\n        self._issuer_invalidator.clear()"
    },
    {
        "code": "def search(self, query, verbose=0):\n        if verbose > 0:\n            print(\"searching \" + query)\n        query = query.lower()\n        qgram = ng(query, self.slb)\n        qocument = set()\n        for q in qgram:\n            if q in self.ngrams.keys():\n                for i in self.ngrams[q]:\n                    qocument.add(i)\n        self.qocument = qocument\n        results = {}\n        for i in qocument:\n           for j in self.D[i].keys():\n                if not j in results.keys():\n                    results[j] = 0\n                results[j] = results[j] + self.D[i][j]\n        sorted_results = sorted(results.items(), key=operator.itemgetter(1), reverse=True)\n        return [self.elements[f[0]] for f in sorted_results]"
    },
    {
        "code": "def layers(self):\n        graph_layers = self.multigraph_layers()\n        try:\n            next(graph_layers)\n        except StopIteration:\n            return\n        def add_nodes_from(layer, nodes):\n            layer._multi_graph.add_nodes_from(nodes)\n        for graph_layer in graph_layers:\n            op_nodes = [node for node in graph_layer if node.type == \"op\"]\n            if not op_nodes:\n                return\n            new_layer = DAGCircuit()\n            new_layer.name = self.name\n            for creg in self.cregs.values():\n                new_layer.add_creg(creg)\n            for qreg in self.qregs.values():\n                new_layer.add_qreg(qreg)\n            add_nodes_from(new_layer, self.input_map.values())\n            add_nodes_from(new_layer, self.output_map.values())\n            add_nodes_from(new_layer, op_nodes)\n            support_list = [\n                op_node.qargs\n                for op_node in op_nodes\n                if op_node.name not in {\"barrier\", \"snapshot\", \"save\", \"load\", \"noise\"}\n            ]\n            wires = {self.input_map[wire]: self.output_map[wire]\n                     for wire in self.wires}\n            for op_node in op_nodes:\n                args = self._bits_in_condition(op_node.condition) \\\n                       + op_node.cargs + op_node.qargs\n                arg_ids = (self.input_map[(arg[0], arg[1])] for arg in args)\n                for arg_id in arg_ids:\n                    wires[arg_id], wires[op_node] = op_node, wires[arg_id]\n            new_layer._multi_graph.add_edges_from(wires.items())\n            yield {\"graph\": new_layer, \"partition\": support_list}"
    },
    {
        "code": "def current_docker_container_id():\n    try:\n        with open('/proc/1/cgroup', 'r') as readable:\n            raw = readable.read()\n        ids = set(re.compile('[0-9a-f]{12,}').findall(raw))\n        assert len(ids) == 1\n        return ids.pop()\n    except:\n        logging.exception('Failed to obtain current container ID')\n        raise NotInsideContainerError()"
    },
    {
        "code": "def get_student_messaging_for_sis_course_id_and_sis_user_id(\n            self, sis_user_id, sis_course_id):\n        url = (\"/api/v1/courses/%s/analytics/\"\n               \"users/sis_user_id:%s/communication.json\") % (\n            self._sis_id(sis_course_id, sis_field=\"course\"), sis_user_id)\n        return self._get_resource(url)"
    },
    {
        "code": "def create_instance(self, instance_id, configuration_name, node_count,\n                        display_name, project_id=None):\n        self._apply_to_instance(project_id, instance_id, configuration_name,\n                                node_count, display_name, lambda x: x.create())"
    },
    {
        "code": "def remove_action(self, action_name, action_id):\n        action = self.get_action(action_name, action_id)\n        if action is None:\n            return False\n        action.cancel()\n        self.actions[action_name].remove(action)\n        return True"
    },
    {
        "code": "def update_x(self, x, indices=None):\n        x = _make_np_bool(x)\n        if indices is None:\n            if len(self._x) != len(x):\n                raise QiskitError(\"During updating whole x, you can not change \"\n                                  \"the number of qubits.\")\n            self._x = x\n        else:\n            if not isinstance(indices, list) and not isinstance(indices, np.ndarray):\n                indices = [indices]\n            for p, idx in enumerate(indices):\n                self._x[idx] = x[p]\n        return self"
    },
    {
        "code": "def _subgraph_parse(\n        self, node, pathnode, extra_blocks\n    ):\n        loose_ends = []\n        self.tail = node\n        self.dispatch_list(node.body)\n        loose_ends.append(self.tail)\n        for extra in extra_blocks:\n            self.tail = node\n            self.dispatch_list(extra.body)\n            loose_ends.append(self.tail)\n        if node.orelse:\n            self.tail = node\n            self.dispatch_list(node.orelse)\n            loose_ends.append(self.tail)\n        else:\n            loose_ends.append(node)\n        if node:\n            bottom = \"%s\" % self._bottom_counter\n            self._bottom_counter += 1\n            for le in loose_ends:\n                self.graph.connect(le, bottom)\n            self.tail = bottom"
    },
    {
        "code": "def set_constant(self, name, value):\n        assert isinstance(name, str) or isinstance(name, sympy.Symbol), \\\n            \"constant name needs to be of type str, unicode or a sympy.Symbol\"\n        assert type(value) is int, \"constant value needs to be of type int\"\n        if isinstance(name, sympy.Symbol):\n            self.constants[name] = value\n        else:\n            self.constants[symbol_pos_int(name)] = value"
    },
    {
        "code": "def parse(cls, parser, token):\n        bits, as_var = parse_as_var(parser, token)\n        tag_name, args, kwargs = parse_token_kwargs(parser, bits, ('template',) + cls.allowed_kwargs, compile_args=cls.compile_args, compile_kwargs=cls.compile_kwargs)\n        cls.validate_args(tag_name, *args)\n        return cls(tag_name, as_var, *args, **kwargs)"
    },
    {
        "code": "def resolves_for(self, session):\n        if self.url:\n            self.actual_path = session.current_url\n        else:\n            result = urlparse(session.current_url)\n            if self.only_path:\n                self.actual_path = result.path\n            else:\n                request_uri = result.path\n                if result.query:\n                    request_uri += \"?{0}\".format(result.query)\n                self.actual_path = request_uri\n        if isregex(self.expected_path):\n            return self.expected_path.search(self.actual_path)\n        else:\n            return normalize_url(self.actual_path) == normalize_url(self.expected_path)"
    },
    {
        "code": "def retrieve_image(self, path_to_image):\n        image = self.storage.open(path_to_image, 'rb')\n        file_ext = path_to_image.rsplit('.')[-1]\n        image_format, mime_type = get_image_metadata_from_file_ext(file_ext)\n        return (\n            Image.open(image),\n            file_ext,\n            image_format,\n            mime_type\n        )"
    },
    {
        "code": "def create_build_package(package_files):\n    for package_file in package_files:\n        if not os.path.exists(package_file):\n            bot.exit('Cannot find %s.' % package_file)\n    bot.log('Generating build package for %s files...' % len(package_files))\n    build_dir = get_tmpdir(prefix=\"sregistry-build\")\n    build_tar = '%s/build.tar.gz' % build_dir\n    tar = tarfile.open(build_tar, \"w:gz\")\n    for package_file in package_files:\n        tar.add(package_file)\n    tar.close()\n    sha256 = get_file_hash(build_tar)\n    hash_tar =  \"%s/%s.tar.gz\" %(build_dir, sha256)\n    shutil.move(build_tar, hash_tar)\n    return hash_tar"
    },
    {
        "code": "def step_next_char(self):\n        self._index += 1\n        self._col_offset += 1\n        if self._index > self._maxindex:\n            self._maxindex = self._index\n            self._maxcol = self._col_offset\n            self._maxline = self._lineno"
    },
    {
        "code": "def _get_cached_arg_spec(fn):\n  arg_spec = _ARG_SPEC_CACHE.get(fn)\n  if arg_spec is None:\n    arg_spec_fn = inspect.getfullargspec if six.PY3 else inspect.getargspec\n    try:\n      arg_spec = arg_spec_fn(fn)\n    except TypeError:\n      arg_spec = arg_spec_fn(fn.__call__)\n    _ARG_SPEC_CACHE[fn] = arg_spec\n  return arg_spec"
    },
    {
        "code": "def export_xhtml(html, filename, image_tag=None):\n    if image_tag is None:\n        image_tag = default_image_tag\n    else:\n        image_tag = ensure_utf8(image_tag)\n    with open(filename, 'w') as f:\n        offset = html.find(\"<html>\")\n        assert offset > -1, 'Invalid HTML string: no <html> tag.'\n        html = ('<html xmlns=\"http://www.w3.org/1999/xhtml\">\\n'+\n                html[offset+6:])\n        html = fix_html(html)\n        f.write(IMG_RE.sub(lambda x: image_tag(x, path = None, format = \"svg\"),\n                           html))"
    },
    {
        "code": "def get_properties(self):\n        return {prop.get_name(): prop.get_value()\n                for prop in self.properties.values()}"
    },
    {
        "code": "def get_card(self, card_id, **query_params):\n        card_json = self.fetch_json(\n            uri_path=self.base_uri + '/cards/' + card_id\n        )\n        return self.create_card(card_json)"
    },
    {
        "code": "def with_context(exc, context):\n    if not hasattr(exc, 'context'):\n        exc.context = {}\n    exc.context.update(context)\n    return exc"
    },
    {
        "code": "def delete(self, url, **kwargs):\n        check_type(url, basestring, may_be_none=False)\n        erc = kwargs.pop('erc', EXPECTED_RESPONSE_CODE['DELETE'])\n        self.request('DELETE', url, erc, **kwargs)"
    },
    {
        "code": "def effective_sample_size(states,\n                          filter_threshold=0.,\n                          filter_beyond_lag=None,\n                          name=None):\n  states_was_list = _is_list_like(states)\n  if not states_was_list:\n    states = [states]\n  filter_beyond_lag = _broadcast_maybelist_arg(states, filter_beyond_lag,\n                                               'filter_beyond_lag')\n  filter_threshold = _broadcast_maybelist_arg(states, filter_threshold,\n                                              'filter_threshold')\n  with tf.compat.v1.name_scope(name, 'effective_sample_size'):\n    ess_list = [\n        _effective_sample_size_single_state(s, ml, mlt)\n        for (s, ml, mlt) in zip(states, filter_beyond_lag, filter_threshold)\n    ]\n  if states_was_list:\n    return ess_list\n  return ess_list[0]"
    },
    {
        "code": "def add_requirements(self, metadata_path):\n        additional = list(self.setupcfg_requirements())\n        if not additional: return\n        pkg_info = read_pkg_info(metadata_path)\n        if 'Provides-Extra' in pkg_info or 'Requires-Dist' in pkg_info:\n            warnings.warn('setup.cfg requirements overwrite values from setup.py')\n            del pkg_info['Provides-Extra']\n            del pkg_info['Requires-Dist']\n        for k, v in additional:\n            pkg_info[k] = v\n        write_pkg_info(metadata_path, pkg_info)"
    },
    {
        "code": "def get_module(self, name, node):\n        for mod in self.modules():\n            mod_name = mod.node.name\n            if mod_name == name:\n                return mod\n            package = node.root().name\n            if mod_name == \"%s.%s\" % (package, name):\n                return mod\n            if mod_name == \"%s.%s\" % (package.rsplit(\".\", 1)[0], name):\n                return mod\n        raise KeyError(name)"
    },
    {
        "code": "def copy(self, copy_source, bucket, key, extra_args=None,\n             subscribers=None, source_client=None):\n        if extra_args is None:\n            extra_args = {}\n        if subscribers is None:\n            subscribers = []\n        if source_client is None:\n            source_client = self._client\n        self._validate_all_known_args(extra_args, self.ALLOWED_COPY_ARGS)\n        call_args = CallArgs(\n            copy_source=copy_source, bucket=bucket, key=key,\n            extra_args=extra_args, subscribers=subscribers,\n            source_client=source_client\n        )\n        return self._submit_transfer(call_args, CopySubmissionTask)"
    },
    {
        "code": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):\n        local_stream = utils.BytearrayStream()\n        if len(self._credentials) == 0:\n            raise ValueError(\"Authentication struct missing credentials.\")\n        for credential in self._credentials:\n            credential.write(local_stream, kmip_version=kmip_version)\n        self.length = local_stream.length()\n        super(Authentication, self).write(\n            output_stream,\n            kmip_version=kmip_version\n        )\n        output_stream.write(local_stream.buffer)"
    },
    {
        "code": "def dims(x):\n  if isinstance(x, tf.TensorShape):\n    return x.dims\n  r = tf.TensorShape(x).dims\n  return None if r is None else list(map(tf.compat.dimension_value, r))"
    },
    {
        "code": "def ancestral_reconstruction(params):\n    if assure_tree(params, tmp_dir='ancestral_tmp'):\n        return 1\n    outdir = get_outdir(params, '_ancestral')\n    basename = get_basename(params, outdir)\n    gtr = create_gtr(params)\n    aln, ref, fixed_pi = read_if_vcf(params)\n    is_vcf = True if ref is not None else False\n    treeanc = TreeAnc(params.tree, aln=aln, ref=ref, gtr=gtr, verbose=1,\n                      fill_overhangs=not params.keep_overhangs)\n    ndiff =treeanc.infer_ancestral_sequences('ml', infer_gtr=params.gtr=='infer',\n                                             marginal=params.marginal, fixed_pi=fixed_pi)\n    if ndiff==ttconf.ERROR:\n        return 1\n    if params.gtr==\"infer\":\n        print('\\nInferred GTR model:')\n        print(treeanc.gtr)\n    export_sequences_and_tree(treeanc, basename, is_vcf, params.zero_based,\n                              report_ambiguous=params.report_ambiguous)\n    return 0"
    },
    {
        "code": "def chain_nac_proxy(chain, sender, contract_address, value=0):\n    \"create an object which acts as a proxy for the contract on the chain\"\n    klass = registry[contract_address].im_self\n    assert issubclass(klass, NativeABIContract)\n    def mk_method(method):\n        def m(s, *args):\n            data = abi_encode_args(method, args)\n            block = chain.head_candidate\n            output = test_call(block, sender, contract_address, data)\n            if output is not None:\n                return abi_decode_return_vals(method, output)\n        return m\n    class cproxy(object):\n        pass\n    for m in klass._abi_methods():\n        setattr(cproxy, m.__func__.func_name, mk_method(m))\n    return cproxy()"
    },
    {
        "code": "def _generate(self, source, name, filename, defer_init=False):\n        return generate(source, self, name, filename, defer_init=defer_init)"
    },
    {
        "code": "def send_json(self, ids=None):\n        items = ids or self._registration_id\n        values = {\"registration_ids\": items}\n        if self._data is not None:\n            values[\"data\"] = self._data\n        for key, val in self._kwargs.items():\n            if val:\n                values[key] = val\n        data = json.dumps(values, separators=(\",\", \":\"), sort_keys=True).encode(\n                self.encoding)\n        result = json.loads(self._send(data, \"application/json\"))\n        if (\"failure\" in result) and (result[\"failure\"]):\n            unregistered = []\n            throw_error = False\n            for index, error in enumerate(result.get(\"results\", [])):\n                error = error.get(\"error\", \"\")\n                if error in (\"NotRegistered\", \"InvalidRegistration\"):\n                    unregistered.append(items[index])\n                elif error != \"\":\n                    throw_error = True\n            self.deactivate_unregistered_devices(unregistered)\n            if throw_error:\n                raise GCMPushError(result)\n        return result"
    },
    {
        "code": "def compounds(context, case_id):\n    adapter = context.obj['adapter']\n    LOG.info(\"Running scout update compounds\")\n    case_obj = adapter.case(case_id)\n    if not case_obj:\n        LOG.warning(\"Case %s could not be found\", case_id)\n        context.abort()\n    try:\n        adapter.update_case_compounds(case_obj)\n    except Exception as err:\n        LOG.warning(err)\n        context.abort()"
    },
    {
        "code": "def try_passwordless_ssh(server, keyfile, paramiko=None):\n    if paramiko is None:\n        paramiko = sys.platform == 'win32'\n    if not paramiko:\n        f = _try_passwordless_openssh\n    else:\n        f = _try_passwordless_paramiko\n    return f(server, keyfile)"
    },
    {
        "code": "def analyze_entities(self, document, encoding_type=None, retry=None, timeout=None, metadata=None):\n        client = self.get_conn()\n        return client.analyze_entities(\n            document=document, encoding_type=encoding_type, retry=retry, timeout=timeout, metadata=metadata\n        )"
    },
    {
        "code": "def __load_symbol_maps(self):\n        repo = SymbolMapRepository(self.__get_session())\n        all_maps = repo.get_all()\n        self.symbol_maps = {}\n        for item in all_maps:\n            self.symbol_maps[item.in_symbol] = item.out_symbol"
    },
    {
        "code": "def connection(self):\n        ctx = _app_ctx_stack.top\n        if ctx is not None:\n            if not hasattr(ctx, 'mysql_db'):\n                ctx.mysql_db = self.connect\n            return ctx.mysql_db"
    },
    {
        "code": "def multiqc(store, institute_id, case_name):\n    institute_obj, case_obj = institute_and_case(store, institute_id, case_name)\n    return dict(\n        institute=institute_obj,\n        case=case_obj,\n    )"
    },
    {
        "code": "def write_change(change):\n    action, rrset = change\n    change_vals = get_change_values(change)\n    e_change = etree.Element(\"Change\")\n    e_action = etree.SubElement(e_change, \"Action\")\n    e_action.text = action\n    e_rrset = etree.SubElement(e_change, \"ResourceRecordSet\")\n    e_name = etree.SubElement(e_rrset, \"Name\")\n    e_name.text = change_vals['name']\n    e_type = etree.SubElement(e_rrset, \"Type\")\n    e_type.text = rrset.rrset_type\n    if change_vals.get('set_identifier'):\n        e_set_id = etree.SubElement(e_rrset, \"SetIdentifier\")\n        e_set_id.text = change_vals['set_identifier']\n    if change_vals.get('weight'):\n        e_weight = etree.SubElement(e_rrset, \"Weight\")\n        e_weight.text = change_vals['weight']\n    if change_vals.get('alias_hosted_zone_id') or change_vals.get('alias_dns_name'):\n        e_alias_target = etree.SubElement(e_rrset, \"AliasTarget\")\n        e_hosted_zone_id = etree.SubElement(e_alias_target, \"HostedZoneId\")\n        e_hosted_zone_id.text = change_vals['alias_hosted_zone_id']\n        e_dns_name = etree.SubElement(e_alias_target, \"DNSName\")\n        e_dns_name.text = change_vals['alias_dns_name']\n    if change_vals.get('region'):\n        e_weight = etree.SubElement(e_rrset, \"Region\")\n        e_weight.text = change_vals['region']\n    e_ttl = etree.SubElement(e_rrset, \"TTL\")\n    e_ttl.text = str(change_vals['ttl'])\n    if rrset.is_alias_record_set():\n        return e_change\n    e_resource_records = etree.SubElement(e_rrset, \"ResourceRecords\")\n    for value in change_vals['records']:\n        e_resource_record = etree.SubElement(e_resource_records, \"ResourceRecord\")\n        e_value = etree.SubElement(e_resource_record, \"Value\")\n        e_value.text = value\n    return e_change"
    },
    {
        "code": "def _init_transformer(cls, data):\n        if isinstance(data, QuantumChannel):\n            return data\n        if hasattr(data, 'to_quantumchannel'):\n            return data.to_channel()\n        if hasattr(data, 'to_channel'):\n            return data.to_channel()\n        return Operator(data)"
    },
    {
        "code": "def _cmd(self, cmd, *args, **kw):\n        ok = kw.setdefault('ok', False)\n        self._wakeup()\n        if args:\n            cmd = \"%s %s\" % (cmd, ' '.join(str(a) for a in args))\n        for i in xrange(3):\n            log.info(\"send: \" + cmd)\n            self.port.write(cmd + '\\n')\n            if ok:\n                ack = self.port.read(len(self.OK))\n                log_raw('read', ack)\n                if ack == self.OK:\n                    return\n            else:\n                ack = self.port.read(len(self.ACK))\n                log_raw('read', ack)\n                if ack == self.ACK:\n                    return\n        raise NoDeviceException('Can not access weather station')"
    },
    {
        "code": "def _index_put(self, idx_name, *ids_and_fcs):\n        keys = self._index_keys_for(idx_name, *ids_and_fcs)\n        with_vals = map(lambda k: (k, '0'), keys)\n        self.kvl.put(self.INDEX_TABLE, *with_vals)"
    },
    {
        "code": "def valid(schema=None):\n        def dec(fun):\n            @wraps(fun)\n            def d_func(self, ctx, data, *a, **kw):\n                try:\n                    validate(data['params'], schema)\n                except ValidationError as err:\n                    raise InvalidParams(err)\n                except SchemaError as err:\n                    raise InternalError(err)\n                return fun(self, ctx, data['params'], *a, **kw)\n            return d_func\n        return dec"
    },
    {
        "code": "def map_thread_names():\n    name2id = {}\n    for thread_id in list(threading._active.keys()):\n        thread = threading._active[thread_id]\n        name = thread.getName()\n        if name not in list(name2id.keys()):\n            name2id[name] = thread_id\n            pass\n        pass\n    return name2id"
    },
    {
        "code": "def _choi_to_kraus(data, input_dim, output_dim, atol=ATOL_DEFAULT):\n    if is_hermitian_matrix(data, atol=atol):\n        w, v = la.eigh(data)\n        if len(w[w < -atol]) == 0:\n            kraus = []\n            for val, vec in zip(w, v.T):\n                if abs(val) > atol:\n                    k = np.sqrt(val) * vec.reshape(\n                        (output_dim, input_dim), order='F')\n                    kraus.append(k)\n            if not kraus:\n                kraus.append(np.zeros((output_dim, input_dim), dtype=complex))\n            return (kraus, None)\n    mat_u, svals, mat_vh = la.svd(data)\n    kraus_l = []\n    kraus_r = []\n    for val, vec_l, vec_r in zip(svals, mat_u.T, mat_vh.conj()):\n        kraus_l.append(\n            np.sqrt(val) * vec_l.reshape((output_dim, input_dim), order='F'))\n        kraus_r.append(\n            np.sqrt(val) * vec_r.reshape((output_dim, input_dim), order='F'))\n    return (kraus_l, kraus_r)"
    },
    {
        "code": "def login(self, *login_args, **login_kwargs):\n        def decorator(f):\n            @wraps(f)\n            def decorated(*args, **kwargs):\n                self.response = make_response()\n                adapter = WerkzeugAdapter(request, self.response)\n                login_kwargs.setdefault('session', session)\n                login_kwargs.setdefault('session_saver', self.session_saver)\n                self.result = super(FlaskAuthomatic, self).login(\n                    adapter,\n                    *login_args,\n                    **login_kwargs)\n                return f(*args, **kwargs)\n            return decorated\n        return decorator"
    },
    {
        "code": "def main(args=None):\n    options, paths = _parse_options(args)\n    format = getattr(options, 'output', 'simple')\n    formatter = _FORMATTERS[format](options)\n    for path in paths:\n        meta = get_metadata(path, options.metadata_version)\n        if meta is None:\n            continue\n        if options.download_url_prefix:\n            if meta.download_url is None:\n                filename = os.path.basename(path)\n                meta.download_url = '%s/%s' % (options.download_url_prefix,\n                                               filename)\n        formatter(meta)\n    formatter.finish()"
    },
    {
        "code": "def _get_format_from_document(self, token, document):\n        code, html = self._formatter._format_lines([(token, u'dummy')]).next()\n        self._document.setHtml(html)\n        return QtGui.QTextCursor(self._document).charFormat()"
    },
    {
        "code": "def authenticate_credentials(self, key):\n        user, token = super(TokenAuthentication, self).authenticate_credentials(key)\n        if token.expires < timezone.now():\n            msg = _('Token has expired.')\n            raise exceptions.AuthenticationFailed(msg)\n        token.update_expiry()\n        return (user, token)"
    },
    {
        "code": "def parse_issues(raw_page):\n        raw_issues = json.loads(raw_page)\n        issues = raw_issues['issues']\n        for issue in issues:\n            yield issue"
    },
    {
        "code": "def nice_pair(pair):\n    start, end = pair\n    if start == end:\n        return \"%d\" % start\n    else:\n        return \"%d-%d\" % (start, end)"
    },
    {
        "code": "def comments(self):\n        record_numbers = range(2, self.fward)\n        if not record_numbers:\n            return ''\n        data = b''.join(self.read_record(n)[0:1000] for n in record_numbers)\n        try:\n            return data[:data.find(b'\\4')].decode('ascii').replace('\\0', '\\n')\n        except IndexError:\n            raise ValueError('DAF file comment area is missing its EOT byte')\n        except UnicodeDecodeError:\n            raise ValueError('DAF file comment area is not ASCII text')"
    },
    {
        "code": "def quadrature_scheme_lognormal_quantiles(\n    loc, scale, quadrature_size,\n    validate_args=False, name=None):\n  with tf.name_scope(name or \"quadrature_scheme_lognormal_quantiles\"):\n    dist = transformed_distribution.TransformedDistribution(\n        distribution=normal.Normal(loc=loc, scale=scale),\n        bijector=exp_bijector.Exp(),\n        validate_args=validate_args)\n    batch_ndims = tensorshape_util.rank(dist.batch_shape)\n    if batch_ndims is None:\n      batch_ndims = tf.shape(input=dist.batch_shape_tensor())[0]\n    def _compute_quantiles():\n      zero = tf.zeros([], dtype=dist.dtype)\n      edges = tf.linspace(zero, 1., quadrature_size + 3)[1:-1]\n      edges = tf.reshape(\n          edges,\n          shape=tf.concat(\n              [[-1], tf.ones([batch_ndims], dtype=tf.int32)], axis=0))\n      quantiles = dist.quantile(edges)\n      perm = tf.concat([tf.range(1, 1 + batch_ndims), [0]], axis=0)\n      quantiles = tf.transpose(a=quantiles, perm=perm)\n      return quantiles\n    quantiles = _compute_quantiles()\n    grid = (quantiles[..., :-1] + quantiles[..., 1:]) / 2.\n    new_shape = tensorshape_util.concatenate(dist.batch_shape,\n                                             [quadrature_size])\n    tensorshape_util.set_shape(grid, new_shape)\n    probs = tf.fill(\n        dims=[quadrature_size], value=1. / tf.cast(quadrature_size, dist.dtype))\n    return grid, probs"
    },
    {
        "code": "def do_debug(self, args):\n        if not args:\n            self.help_fn(\"What information would you like: data, sys?\")\n            return ERR\n        for info in args:\n            if info == 'sys':\n                print(\"-- sys ----------------------------------------\")\n                for line in info_formatter(self.coverage.sysinfo()):\n                    print(\" %s\" % line)\n            elif info == 'data':\n                print(\"-- data ---------------------------------------\")\n                self.coverage.load()\n                print(\"path: %s\" % self.coverage.data.filename)\n                print(\"has_arcs: %r\" % self.coverage.data.has_arcs())\n                summary = self.coverage.data.summary(fullpath=True)\n                if summary:\n                    filenames = sorted(summary.keys())\n                    print(\"\\n%d files:\" % len(filenames))\n                    for f in filenames:\n                        print(\"%s: %d lines\" % (f, summary[f]))\n                else:\n                    print(\"No data collected\")\n            else:\n                self.help_fn(\"Don't know what you mean by %r\" % info)\n                return ERR\n        return OK"
    },
    {
        "code": "def read_channel(self):\n        channel, message = self.protocol.channel_layer.receive_many([u'slack.send'], block=False)\n        delay = 0.1\n        if channel:\n            self.protocols[0].sendSlack(message)\n        reactor.callLater(delay, self.read_channel)"
    },
    {
        "code": "def check_range(self, j):\n        if isinstance(j, int):\n            if j < 0 or j >= self.size:\n                raise QiskitIndexError(\"register index out of range\")\n            elif isinstance(j, slice):\n                if j.start < 0 or j.stop >= self.size or (j.step is not None and\n                                                          j.step <= 0):\n                    raise QiskitIndexError(\"register index slice out of range\")"
    },
    {
        "code": "def split_vert_on_nonmanifold_face(script, vert_displacement_ratio=0.0):\n    filter_xml = ''.join([\n        '  <filter name=\"Split Vertexes Incident on Non Manifold Faces\">\\n',\n        '    <Param name=\"VertDispRatio\" ',\n        'value=\"{}\" '.format(vert_displacement_ratio),\n        'description=\"Vertex Displacement Ratio\" ',\n        'type=\"RichFloat\" ',\n        '/>\\n',\n        '  </filter>\\n'])\n    util.write_filter(script, filter_xml)\n    return None"
    },
    {
        "code": "def strsplit(self, pattern):\n        fr = H2OFrame._expr(expr=ExprNode(\"strsplit\", self, pattern))\n        fr._ex._cache.nrows = self.nrow\n        return fr"
    },
    {
        "code": "def setup_cmd_parser(cls):\n        parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,\n                                              from_date=True,\n                                              token_auth=True,\n                                              archive=True)\n        action = parser.parser._option_string_actions['--api-token']\n        action.required = True\n        group = parser.parser.add_argument_group('Slack arguments')\n        group.add_argument('--max-items', dest='max_items',\n                           type=int, default=MAX_ITEMS,\n                           help=\"Maximum number of items requested on the same query\")\n        parser.parser.add_argument('channel',\n                                   help=\"Slack channel identifier\")\n        return parser"
    },
    {
        "code": "def _step_decorator_args(self, decorator):\n        args = decorator.children[3:-2]\n        step = None\n        if len(args) == 1:\n            try:\n                step = ast.literal_eval(args[0].get_code())\n            except (ValueError, SyntaxError):\n                pass\n            if isinstance(step, six.string_types+(list,)):\n                return step\n            logging.error(\"Decorator step accepts either a string or a list of strings - %s:%d\",\n                          self.file_path, decorator.start_pos[0])\n        else:\n            logging.error(\"Decorator step accepts only one argument - %s:%d\",\n                          self.file_path, decorator.start_pos[0])"
    },
    {
        "code": "def _create_prefix(self, dirname):\n        if dirname in ('.', '/'):\n            dirname = ''\n        prefix = os.path.join(self._bucket_root, dirname)\n        prefix = prefix.rstrip('/')\n        return prefix"
    },
    {
        "code": "def build_fake_input_fns(batch_size):\n  num_words = 1000\n  vocabulary = [str(i) for i in range(num_words)]\n  random_sample = np.random.randint(\n      10, size=(batch_size, num_words)).astype(np.float32)\n  def train_input_fn():\n    dataset = tf.data.Dataset.from_tensor_slices(random_sample)\n    dataset = dataset.batch(batch_size).repeat()\n    return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()\n  def eval_input_fn():\n    dataset = tf.data.Dataset.from_tensor_slices(random_sample)\n    dataset = dataset.batch(batch_size)\n    return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()\n  return train_input_fn, eval_input_fn, vocabulary"
    },
    {
        "code": "def voronoi(script, hole_num=50, target_layer=None, sample_layer=None, thickness=0.5, backward=True):\n    if target_layer is None:\n        target_layer = script.current_layer()\n    if sample_layer is None:\n        sampling.poisson_disk(script, sample_num=hole_num)\n        sample_layer = script.last_layer()\n    vert_color.voronoi(script, target_layer=target_layer, source_layer=sample_layer, backward=backward)\n    select.vert_quality(script, min_quality=0.0, max_quality=thickness)\n    if backward:\n        select.invert(script)\n    delete.selected(script)\n    smooth.laplacian(script, iterations=3)\n    return None"
    },
    {
        "code": "def get_ip(self):\n        if len(self.client_nodes) > 0:\n            node = self.client_nodes[0]\n        else:\n            node = self.nodes[0]\n        return node.get_ip()"
    },
    {
        "code": "def project_dict(self, project_name, token_name, public):\n        project_dict = {}\n        project_dict['project_name'] = project_name\n        if token_name is not None:\n            if token_name == '':\n                project_dict['token_name'] = project_name\n            else:\n                project_dict['token_name'] = token_name\n        else:\n            project_dict['token_name'] = project_name\n        if public is not None:\n            project_dict['public'] = public\n        return project_dict"
    },
    {
        "code": "def extract_tar(archive, output_folder, handle_whiteout=False):\n    from .terminal import run_command\n    if handle_whiteout is True:\n        return _extract_tar(archive, output_folder)\n    args = '-xf'\n    if archive.endswith(\".tar.gz\"):\n        args = '-xzf'\n    command = [\"tar\", args, archive, \"-C\", output_folder, \"--exclude=dev/*\"]\n    if not bot.is_quiet():\n        print(\"Extracting %s\" % archive)\n    return run_command(command)"
    },
    {
        "code": "def walk_upgrade_domain(self, service_name, deployment_name,\n                            upgrade_domain):\n        _validate_not_none('service_name', service_name)\n        _validate_not_none('deployment_name', deployment_name)\n        _validate_not_none('upgrade_domain', upgrade_domain)\n        return self._perform_post(\n            self._get_deployment_path_using_name(\n                service_name, deployment_name) + '/?comp=walkupgradedomain',\n            _XmlSerializer.walk_upgrade_domain_to_xml(\n                upgrade_domain),\n            as_async=True)"
    },
    {
        "code": "def get_clinvar_id(self, submission_id):\n        submission_obj = self.clinvar_submission_collection.find_one({'_id': ObjectId(submission_id)})\n        clinvar_subm_id = submission_obj.get('clinvar_subm_id')\n        return clinvar_subm_id"
    },
    {
        "code": "def generate_sentence(self, chain):\n        def weighted_choice(choices):\n            total_weight = sum(weight for val, weight in choices)\n            rand = random.uniform(0, total_weight)\n            upto = 0\n            for val, weight in choices:\n                if upto + weight >= rand:\n                    return val\n                upto += weight\n        sentence = list(random.choice(chain.startwords))\n        while not sentence[-1][-1] in ['.', '?', '!']:\n            sentence.append(\n                weighted_choice(\n                    chain.content[tuple(sentence[-2:])].items()\n                )\n            )\n        return ' '.join(sentence)"
    },
    {
        "code": "def _bisect(value_and_gradients_function, initial_args, f_lim):\n  def _loop_cond(curr):\n    return ~tf.reduce_all(input_tensor=curr.stopped)\n  def _loop_body(curr):\n    mid = value_and_gradients_function((curr.left.x + curr.right.x) / 2)\n    failed = (curr.failed | ~is_finite(mid) |\n              tf.equal(mid.x, curr.left.x) | tf.equal(mid.x, curr.right.x))\n    to_update = ~(curr.stopped | failed)\n    update_left = (mid.df < 0) & (mid.f <= f_lim)\n    left = val_where(to_update & update_left, mid, curr.left)\n    right = val_where(to_update & ~update_left, mid, curr.right)\n    stopped = curr.stopped | failed | (right.df >= 0)\n    return [_IntermediateResult(\n        iteration=curr.iteration,\n        stopped=stopped,\n        failed=failed,\n        num_evals=curr.num_evals + 1,\n        left=left,\n        right=right)]\n  return tf.while_loop(\n      cond=_loop_cond, body=_loop_body, loop_vars=[initial_args])[0]"
    },
    {
        "code": "def from_pandas(df, name=\"pandas\", copy_index=True, index_name=\"index\"):\n    import six\n    vaex_df = vaex.dataframe.DataFrameArrays(name)\n    def add(name, column):\n        values = column.values\n        try:\n            vaex_df.add_column(name, values)\n        except Exception as e:\n            print(\"could not convert column %s, error: %r, will try to convert it to string\" % (name, e))\n            try:\n                values = values.astype(\"S\")\n                vaex_df.add_column(name, values)\n            except Exception as e:\n                print(\"Giving up column %s, error: %r\" % (name, e))\n    for name in df.columns:\n        add(name, df[name])\n    if copy_index:\n        add(index_name, df.index)\n    return vaex_df"
    },
    {
        "code": "def network_to_pandas_hdf5(network, filename, rm_nodes=None):\n    if rm_nodes is not None:\n        nodes, edges = remove_nodes(network, rm_nodes)\n    else:\n        nodes, edges = network.nodes_df, network.edges_df\n    with pd.HDFStore(filename, mode='w') as store:\n        store['nodes'] = nodes\n        store['edges'] = edges\n        store['two_way'] = pd.Series([network._twoway])\n        store['impedance_names'] = pd.Series(network.impedance_names)"
    },
    {
        "code": "def build_all_iop(self):\n        lg.info('Building all b and c from IOPs')\n        self.build_a()\n        self.build_bb()\n        self.build_b()\n        self.build_c()"
    },
    {
        "code": "def _put_information(self):\r\n        self.session._add_object()\r\n        self.session._out('<<')\r\n        self.session._out('/Producer ' + self._text_to_string(\r\n            'PDFLite, https://github.com/katerina7479'))\r\n        if self.title:\r\n            self.session._out('/Title ' + self._text_to_string(self.title))\r\n        if self.subject:\r\n            self.session._out('/Subject ' + self._text_to_string(self.subject))\r\n        if self.author:\r\n            self.session._out('/Author ' + self._text_to_string(self.author))\r\n        if self.keywords:\r\n            self.session._out('/Keywords ' +\r\n                              self._text_to_string(self.keywords))\r\n        if self.creator:\r\n            self.session._out('/Creator ' + self._text_to_string(self.creator))\r\n        self.session._out('/CreationDate ' + self._text_to_string(\r\n            'D:' + datetime.now().strftime('%Y%m%d%H%M%S')))\r\n        self.session._out('>>')\r\n        self.session._out('endobj')"
    },
    {
        "code": "def get_rendition_key_set(key):\n    try:\n        rendition_key_set = IMAGE_SETS[key]\n    except KeyError:\n        raise ImproperlyConfigured(\n            \"No Rendition Key Set exists at \"\n            \"settings.VERSATILEIMAGEFIELD_RENDITION_KEY_SETS['{}']\".format(key)\n        )\n    else:\n        return validate_versatileimagefield_sizekey_list(rendition_key_set)"
    },
    {
        "code": "def _method_magic_marker(magic_kind):\n    validate_type(magic_kind)\n    def magic_deco(arg):\n        call = lambda f, *a, **k: f(*a, **k)\n        if callable(arg):\n            func = arg\n            name = func.func_name\n            retval = decorator(call, func)\n            record_magic(magics, magic_kind, name, name)\n        elif isinstance(arg, basestring):\n            name = arg\n            def mark(func, *a, **kw):\n                record_magic(magics, magic_kind, name, func.func_name)\n                return decorator(call, func)\n            retval = mark\n        else:\n            raise TypeError(\"Decorator can only be called with \"\n                            \"string or function\")\n        return retval\n    magic_deco.__doc__ = _docstring_template.format('method', magic_kind)\n    return magic_deco"
    },
    {
        "code": "def get_management_certificate(self, thumbprint):\n        _validate_not_none('thumbprint', thumbprint)\n        return self._perform_get(\n            '/' + self.subscription_id + '/certificates/' + _str(thumbprint),\n            SubscriptionCertificate)"
    },
    {
        "code": "def key_wrapping_data(self):\n        key_wrapping_data = {}\n        encryption_key_info = {\n            'unique_identifier': self._kdw_eki_unique_identifier,\n            'cryptographic_parameters': {\n                'block_cipher_mode': self._kdw_eki_cp_block_cipher_mode,\n                'padding_method': self._kdw_eki_cp_padding_method,\n                'hashing_algorithm': self._kdw_eki_cp_hashing_algorithm,\n                'key_role_type': self._kdw_eki_cp_key_role_type,\n                'digital_signature_algorithm':\n                    self._kdw_eki_cp_digital_signature_algorithm,\n                'cryptographic_algorithm':\n                    self._kdw_eki_cp_cryptographic_algorithm,\n                'random_iv': self._kdw_eki_cp_random_iv,\n                'iv_length': self._kdw_eki_cp_iv_length,\n                'tag_length': self._kdw_eki_cp_tag_length,\n                'fixed_field_length': self._kdw_eki_cp_fixed_field_length,\n                'invocation_field_length':\n                    self._kdw_eki_cp_invocation_field_length,\n                'counter_length': self._kdw_eki_cp_counter_length,\n                'initial_counter_value':\n                    self._kdw_eki_cp_initial_counter_value\n            }\n        }\n        if not any(encryption_key_info['cryptographic_parameters'].values()):\n            encryption_key_info['cryptographic_parameters'] = {}\n        if not any(encryption_key_info.values()):\n            encryption_key_info = {}\n        mac_sign_key_info = {\n            'unique_identifier': self._kdw_mski_unique_identifier,\n            'cryptographic_parameters': {\n                'block_cipher_mode': self._kdw_mski_cp_block_cipher_mode,\n                'padding_method': self._kdw_mski_cp_padding_method,\n                'hashing_algorithm': self._kdw_mski_cp_hashing_algorithm,\n                'key_role_type': self._kdw_mski_cp_key_role_type,\n                'digital_signature_algorithm':\n                    self._kdw_mski_cp_digital_signature_algorithm,\n                'cryptographic_algorithm':\n                    self._kdw_mski_cp_cryptographic_algorithm,\n                'random_iv': self._kdw_mski_cp_random_iv,\n                'iv_length': self._kdw_mski_cp_iv_length,\n                'tag_length': self._kdw_mski_cp_tag_length,\n                'fixed_field_length': self._kdw_mski_cp_fixed_field_length,\n                'invocation_field_length':\n                    self._kdw_mski_cp_invocation_field_length,\n                'counter_length': self._kdw_mski_cp_counter_length,\n                'initial_counter_value':\n                    self._kdw_mski_cp_initial_counter_value\n            }\n        }\n        if not any(mac_sign_key_info['cryptographic_parameters'].values()):\n            mac_sign_key_info['cryptographic_parameters'] = {}\n        if not any(mac_sign_key_info.values()):\n            mac_sign_key_info = {}\n        key_wrapping_data['wrapping_method'] = self._kdw_wrapping_method\n        key_wrapping_data['encryption_key_information'] = encryption_key_info\n        key_wrapping_data['mac_signature_key_information'] = mac_sign_key_info\n        key_wrapping_data['mac_signature'] = self._kdw_mac_signature\n        key_wrapping_data['iv_counter_nonce'] = self._kdw_iv_counter_nonce\n        key_wrapping_data['encoding_option'] = self._kdw_encoding_option\n        if not any(key_wrapping_data.values()):\n            key_wrapping_data = {}\n        return key_wrapping_data"
    },
    {
        "code": "def encode(self):\n        header    = bytearray(1)\n        varHeader = bytearray()\n        payload   = bytearray()\n        header[0] = 0x10\n        varHeader.extend(encodeString(self.version['tag'])) \n        varHeader.append(self.version['level'])\n        flags =  (self.cleanStart << 1)\n        if  self.willTopic is not None and self.willMessage is not None:\n            flags |= 0x04 | (self.willRetain << 5) | (self.willQoS << 3)\n        if self.username is not None:\n            flags |= 0x80\n        if self.password is not None:\n            flags |= 0x40\n        varHeader.append(flags)\n        varHeader.extend(encode16Int(self.keepalive))\n        payload.extend(encodeString(self.clientId))\n        if self.willTopic is not None and self.willMessage is not None:\n            payload.extend(encodeString(self.willTopic))\n            payload.extend(encodeString(self.willMessage))\n        if self.username is not None:\n             payload.extend(encodeString(self.username))\n        if self.password is not None:\n            payload.extend(encode16Int(len(self.password)))\n            payload.extend(bytearray(self.password, encoding='ascii', errors='ignore'))\n        header.extend(encodeLength(len(varHeader) + len(payload)))\n        header.extend(varHeader)\n        header.extend(payload)\n        self.encoded = header\n        return str(header) if PY2 else bytes(header)"
    },
    {
        "code": "def stop_step(self, step_name):\n        if self.finished is not None:\n            raise AlreadyFinished()\n        steps = copy.deepcopy(self.steps)\n        step_data = self._get_step(step_name, steps=steps)\n        if step_data is None:\n            raise StepNotStarted()\n        elif 'stop' in step_data:\n            raise StepAlreadyFinished()\n        step_data['stop'] = datetime.utcnow()\n        step_data['duration'] = util.timedelta_total_seconds(step_data['stop'] - step_data['start'])\n        self._save(steps=steps)"
    },
    {
        "code": "def _notebook_model_from_db(self, record, content):\n        path = to_api_path(record['parent_name'] + record['name'])\n        model = base_model(path)\n        model['type'] = 'notebook'\n        model['last_modified'] = model['created'] = record['created_at']\n        if content:\n            content = reads_base64(record['content'])\n            self.mark_trusted_cells(content, path)\n            model['content'] = content\n            model['format'] = 'json'\n            self.validate_notebook_model(model)\n        return model"
    },
    {
        "code": "def signal_kernel(self, signum):\n        if self.has_kernel:\n            self.kernel.send_signal(signum)\n        else:\n            raise RuntimeError(\"Cannot signal kernel. No kernel is running!\")"
    },
    {
        "code": "def _header_constructor(\n        cls, data_to_print, header_separator=\"-\", column_separator=\" \"\n    ):\n        header_data = []\n        header_size = \"\"\n        before_size = \"%-\"\n        after_size = \"s\"\n        if header_separator:\n            header_separator_data = []\n        length_data_to_print = len(data_to_print) - 1\n        i = 0\n        for data in data_to_print:\n            size = data_to_print[data]\n            header_data.append(data)\n            header_size += before_size + str(size) + after_size\n            if i < length_data_to_print:\n                header_size += column_separator\n            if header_separator:\n                header_separator_data.append(header_separator * size)\n            i += 1\n        if header_separator:\n            return [\n                header_size % tuple(header_data),\n                header_size % tuple(header_separator_data),\n            ]\n        return [header_size % tuple(header_data)]"
    },
    {
        "code": "def equals_order_sensitive(self, other):\n        if not isinstance(other, Mapping) or len(self) != len(other):\n            return False\n        return all(i == j for (i, j) in izip(iteritems(self), iteritems(other)))"
    },
    {
        "code": "def admin_footer(parser, token):\n    tag_name = token.split_contents()\n    if len(tag_name) > 1:\n        raise base.TemplateSyntaxError(\n            '{} tag does not accept any argument(s): {}'.format(\n            token.contents.split()[0],\n            ', '.join(token.contents.split()[1:])\n    ))\n    return AdminFooterNode()"
    },
    {
        "code": "def next(self):\n        val = self._current\n        self._current = self.readfunc()\n        return val"
    },
    {
        "code": "def create(self):\n        if not os.path.exists(self.path):\n            open(self.path, 'a').close()\n        else:\n            raise Exception(\"File exists: {}\".format(self.path))"
    },
    {
        "code": "def write_json_report(sample_id, data1, data2):\n    parser_map = {\n        \"base_sequence_quality\": \">>Per base sequence quality\",\n        \"sequence_quality\": \">>Per sequence quality scores\",\n        \"base_gc_content\": \">>Per sequence GC content\",\n        \"base_n_content\": \">>Per base N content\",\n        \"sequence_length_dist\": \">>Sequence Length Distribution\",\n        \"per_base_sequence_content\": \">>Per base sequence content\"\n    }\n    json_dic = {\n        \"plotData\": [{\n            \"sample\": sample_id,\n            \"data\": {\n                \"base_sequence_quality\": {\"status\": None, \"data\": []},\n                \"sequence_quality\": {\"status\": None, \"data\": []},\n                \"base_gc_content\": {\"status\": None, \"data\": []},\n                \"base_n_content\": {\"status\": None, \"data\": []},\n                \"sequence_length_dist\": {\"status\": None, \"data\": []},\n                \"per_base_sequence_content\": {\"status\": None, \"data\": []}\n            }\n        }]\n    }\n    for cat, start_str in parser_map.items():\n        if cat == \"per_base_sequence_content\":\n            fs = 1\n            fe = 5\n        else:\n            fs = 1\n            fe = 2\n        report1, status1 = _get_quality_stats(data1, start_str,\n                                              field_start=fs, field_end=fe)\n        report2, status2 = _get_quality_stats(data2, start_str,\n                                              field_start=fs, field_end=fe)\n        status = None\n        for i in [\"fail\", \"warn\", \"pass\"]:\n            if i in [status1, status2]:\n                status = i\n        json_dic[\"plotData\"][0][\"data\"][cat][\"data\"] = [report1, report2]\n        json_dic[\"plotData\"][0][\"data\"][cat][\"status\"] = status\n    return json_dic"
    },
    {
        "code": "def case_insensitive(self, fields_dict):\n        if hasattr(self.model, 'CASE_INSENSITIVE_FIELDS'):\n            for field in self.model.CASE_INSENSITIVE_FIELDS:\n                if field in fields_dict:\n                    fields_dict[field + '__iexact'] = fields_dict[field]\n                    del fields_dict[field]"
    },
    {
        "code": "def trim_data_back_to(monthToKeep):\n    global g_failed_tests_info_dict\n    current_time = time.time()\n    oldest_time_allowed = current_time - monthToKeep*30*24*3600\n    clean_up_failed_test_dict(oldest_time_allowed)\n    clean_up_summary_text(oldest_time_allowed)"
    },
    {
        "code": "def fill(self, doc_contents):\n        for key, content in doc_contents.items():\n            doc_contents[key] = replace_chars_for_svg_code(content)\n        return super(SVGDocument, self).fill(doc_contents=doc_contents)"
    },
    {
        "code": "def In(sigOrVal, iterable):\n    res = None\n    for i in iterable:\n        i = toHVal(i)\n        if res is None:\n            res = sigOrVal._eq(i)\n        else:\n            res = res | sigOrVal._eq(i)\n    assert res is not None, \"Parameter iterable is empty\"\n    return res"
    },
    {
        "code": "def set_client_certificate(self, certificate):\n        _certificate = BSTR(certificate)\n        _WinHttpRequest._SetClientCertificate(self, _certificate)"
    },
    {
        "code": "def validate_chunks(self, chunks):\n        starts = set([ch.byte for ch in chunks])\n        for ch in chunks:\n            assert all([(ex in starts or ex < 0) for ex in ch.exits])"
    },
    {
        "code": "def get_external_tools_in_account(self, account_id, params={}):\n        url = ACCOUNTS_API.format(account_id) + \"/external_tools\"\n        external_tools = []\n        for data in self._get_paged_resource(url, params=params):\n            external_tools.append(data)\n        return external_tools"
    },
    {
        "code": "def execute(self, context):\n        self.hook = DiscordWebhookHook(\n            self.http_conn_id,\n            self.webhook_endpoint,\n            self.message,\n            self.username,\n            self.avatar_url,\n            self.tts,\n            self.proxy\n        )\n        self.hook.execute()"
    },
    {
        "code": "def make_dict_observable(matrix_observable):\n    dict_observable = {}\n    observable = np.array(matrix_observable)\n    observable_size = len(observable)\n    observable_bits = int(np.ceil(np.log2(observable_size)))\n    binary_formater = '0{}b'.format(observable_bits)\n    if observable.ndim == 2:\n        observable = observable.diagonal()\n    for state_no in range(observable_size):\n        state_str = format(state_no, binary_formater)\n        dict_observable[state_str] = observable[state_no]\n    return dict_observable"
    },
    {
        "code": "def _check_wiremap_validity(self, wire_map, keymap, valmap):\n        for k, v in wire_map.items():\n            kname = \"%s[%d]\" % (k[0].name, k[1])\n            vname = \"%s[%d]\" % (v[0].name, v[1])\n            if k not in keymap:\n                raise DAGCircuitError(\"invalid wire mapping key %s\" % kname)\n            if v not in valmap:\n                raise DAGCircuitError(\"invalid wire mapping value %s\" % vname)\n            if type(k) is not type(v):\n                raise DAGCircuitError(\"inconsistent wire_map at (%s,%s)\" %\n                                      (kname, vname))"
    },
    {
        "code": "def pformat_dict_summary_html(dict):\n    if not dict:\n        return '   {}'\n    html = []\n    for key, value in sorted(six.iteritems(dict)):\n        if not isinstance(value, DICT_EXPANDED_TYPES):\n            value = '...'\n        html.append(_format_dict_item(key, value))\n    return mark_safe(u'<br/>'.join(html))"
    },
    {
        "code": "def selected(self):\n        if self._selected:\n            return self._selected if self.asc else \\\n                \"-{0}\".format(self._selected)\n        return None"
    },
    {
        "code": "def _helpful_failure(method):\n    @wraps(method)\n    def wrapper(self, val):\n        try:\n            return method(self, val)\n        except:\n            exc_cls, inst, tb = sys.exc_info()\n            if hasattr(inst, '_RERAISE'):\n                _, expr, _, inner_val = Q.__debug_info__\n                Q.__debug_info__ = QDebug(self, expr, val, inner_val)\n                raise\n            if issubclass(exc_cls, KeyError):\n                exc_cls = QKeyError\n            prettyval = repr(val)\n            if len(prettyval) > 150:\n                prettyval = \"<%s instance>\" % (type(val).__name__)\n            msg = \"{0}\\n\\n\\tEncountered when evaluating {1}{2}\".format(\n                inst, prettyval, self)\n            new_exc = exc_cls(msg)\n            new_exc._RERAISE = True\n            Q.__debug_info__ = QDebug(self, self, val, val)\n            six.reraise(exc_cls, new_exc, tb)\n    return wrapper"
    },
    {
        "code": "def _add_to_tree(self, start_node, split_names, type_name, group_type_name,\n                     instance, constructor, args, kwargs):\n        try:\n            act_node = start_node\n            last_idx = len(split_names) - 1\n            add_link = type_name == LINK\n            link_added = False\n            for idx, name in enumerate(split_names):\n                if name not in act_node._children:\n                    if idx == last_idx:\n                        if add_link:\n                            new_node = self._create_link(act_node, name, instance)\n                            link_added = True\n                        elif group_type_name != type_name:\n                            new_node = self._create_any_param_or_result(act_node,\n                                                                        name,\n                                                                        type_name,\n                                                                        instance,\n                                                                        constructor,\n                                                                        args, kwargs)\n                            self._flat_leaf_storage_dict[new_node.v_full_name] = new_node\n                        else:\n                            new_node = self._create_any_group(act_node, name,\n                                                              group_type_name,\n                                                              instance,\n                                                              constructor,\n                                                              args, kwargs)\n                    else:\n                        new_node = self._create_any_group(act_node, name,\n                                                          group_type_name)\n                    if name in self._root_instance._run_information:\n                        self._root_instance._run_parent_groups[act_node.v_full_name] = act_node\n                    if self._root_instance._is_run:\n                        if link_added:\n                            self._root_instance._new_links[(act_node.v_full_name, name)] = \\\n                                (act_node, new_node)\n                        else:\n                            self._root_instance._new_nodes[(act_node.v_full_name, name)] = \\\n                                (act_node, new_node)\n                else:\n                    if name in act_node._links:\n                        raise AttributeError('You cannot hop over links when adding '\n                                             'data to the tree. '\n                                             'There is a link called `%s` under `%s`.' %\n                                             (name, act_node.v_full_name))\n                    if idx == last_idx:\n                        if self._root_instance._no_clobber:\n                            self._logger.warning('You already have a group/instance/link `%s` '\n                                                 'under `%s`. '\n                                                 'However, you set `v_no_clobber=True`, '\n                                                 'so I will ignore your addition of '\n                                                 'data.' % (name, act_node.v_full_name))\n                        else:\n                            raise AttributeError('You already have a group/instance/link `%s` '\n                                                 'under `%s`' % (name, act_node.v_full_name))\n                act_node = act_node._children[name]\n            return act_node\n        except:\n            self._logger.error('Failed adding `%s` under `%s`.' %\n                               (name, start_node.v_full_name))\n            raise"
    },
    {
        "code": "def tostring(self):\n        root = self.as_element()\n        indent(root)\n        txt = ET.tostring(root, encoding=\"utf-8\")\n        txt = re.sub(r'_[A-Z]_','',txt)\n        txt = '<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n' + txt\n        return txt"
    },
    {
        "code": "def __head(self,h):\n        return '%s%s%s' % (self.color_table.active_colors.header,h,\n                           self.color_table.active_colors.normal)"
    },
    {
        "code": "def publish(\n            self, resource_group_name, automation_account_name, runbook_name, custom_headers=None, raw=False, polling=True, **operation_config):\n        raw_result = self._publish_initial(\n            resource_group_name=resource_group_name,\n            automation_account_name=automation_account_name,\n            runbook_name=runbook_name,\n            custom_headers=custom_headers,\n            raw=True,\n            **operation_config\n        )\n        def get_long_running_output(response):\n            if raw:\n                client_raw_response = ClientRawResponse(None, response)\n                client_raw_response.add_headers({\n                    'location': 'str',\n                })\n                return client_raw_response\n        lro_delay = operation_config.get(\n            'long_running_operation_timeout',\n            self.config.long_running_operation_timeout)\n        if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)\n        elif polling is False: polling_method = NoPolling()\n        else: polling_method = polling\n        return LROPoller(self._client, raw_result, get_long_running_output, polling_method)"
    },
    {
        "code": "def get_rules(self) -> parsing.Node:\n        res = None\n        try:\n            res = self.eval_rule('bnf_dsl')\n            if not res:\n                self.diagnostic.notify(\n                    error.Severity.ERROR,\n                    \"Parse error in '%s' in EBNF bnf\" % self._lastRule,\n                    error.LocationInfo.from_maxstream(self._stream)\n                )\n                raise self.diagnostic\n        except error.Diagnostic as d:\n            d.notify(\n                error.Severity.ERROR,\n                \"Parse error in '%s' in EBNF bnf\" % self._lastRule\n            )\n            raise d\n        return res"
    },
    {
        "code": "def save(self, filename=None, deleteid3=False):\n        if filename is None:\n            filename = self.filename\n        f = open(filename, 'rb+')\n        try:\n            self.metadata_blocks.append(Padding(b'\\x00' * 1020))\n            MetadataBlock.group_padding(self.metadata_blocks)\n            header = self.__check_header(f)\n            available = self.__find_audio_offset(f) - header\n            data = MetadataBlock.writeblocks(self.metadata_blocks)\n            if deleteid3 and header > 4:\n                available += header - 4\n                header = 4\n            if len(data) > available:\n                padding = self.metadata_blocks[-1]\n                newlength = padding.length - (len(data) - available)\n                if newlength > 0:\n                    padding.length = newlength\n                    data = MetadataBlock.writeblocks(self.metadata_blocks)\n                    assert len(data) == available\n            elif len(data) < available:\n                self.metadata_blocks[-1].length += (available - len(data))\n                data = MetadataBlock.writeblocks(self.metadata_blocks)\n                assert len(data) == available\n            if len(data) != available:\n                diff = (len(data) - available)\n                insert_bytes(f, diff, header)\n            f.seek(header - 4)\n            f.write(b\"fLaC\" + data)\n            if deleteid3:\n                try:\n                    f.seek(-128, 2)\n                except IOError:\n                    pass\n                else:\n                    if f.read(3) == b\"TAG\":\n                        f.seek(-128, 2)\n                        f.truncate()\n        finally:\n            f.close()"
    },
    {
        "code": "def text(self, etype, value, tb, tb_offset=None, context=5):\n        tb_list = self.structured_traceback(etype, value, tb,\n                                            tb_offset, context)\n        return self.stb2text(tb_list)"
    },
    {
        "code": "def child_object(self):\n        from . import types\n        child_klass = types.get(self.task_type.split('.')[1])\n        return child_klass.retrieve(self.task_id, client=self._client)"
    },
    {
        "code": "def controller_factory(cls, passes, options, **partial_controller):\n        if None in partial_controller.values():\n            raise TranspilerError('The controller needs a condition.')\n        if partial_controller:\n            for registered_controller in cls.registered_controllers.keys():\n                if registered_controller in partial_controller:\n                    return cls.registered_controllers[registered_controller](passes, options,\n                                                                             **partial_controller)\n            raise TranspilerError(\"The controllers for %s are not registered\" % partial_controller)\n        else:\n            return FlowControllerLinear(passes, options)"
    },
    {
        "code": "def sprint(text, *colors):\n    return \"\\33[{}m{content}\\33[{}m\".format(\";\".join([str(color) for color in colors]), RESET, content=text) if IS_ANSI_TERMINAL and colors else text"
    },
    {
        "code": "def __build_question(html_question, question, comments):\n        question_object = {}\n        question_container = AskbotParser.parse_question_container(html_question[0])\n        question_object.update(question_container)\n        if comments[int(question['id'])]:\n            question_object['comments'] = comments[int(question['id'])]\n        answers = []\n        for page in html_question:\n            answers.extend(AskbotParser.parse_answers(page))\n        if len(answers) != 0:\n            question_object['answers'] = answers\n            for answer in question_object['answers']:\n                if comments[int(answer['id'])]:\n                    answer['comments'] = comments[int(answer['id'])]\n        return question_object"
    },
    {
        "code": "def gpio_interrupts_enable(self):\n        try:\n            bring_gpio_interrupt_into_userspace()\n            set_gpio_interrupt_edge()\n        except Timeout as e:\n            raise InterruptEnableException(\n                \"There was an error bringing gpio%d into userspace. %s\" %\n                (GPIO_INTERRUPT_PIN, e.message)\n            )"
    },
    {
        "code": "def request(self, method, url, **kwargs):\n        opts = {\n            'allow_redirects': True,\n            'auth': self._auth,\n            'data': {},\n            'files': None,\n            'headers': dict(self._headers),\n            'params': {},\n            'timeout': 80,\n            'verify': True\n        }\n        raw = kwargs.pop('raw', False)\n        debug = kwargs.pop('debug', False)\n        opts.update(kwargs)\n        method = method.upper()\n        if opts['files']:\n            opts['headers'].pop('Content-Type', None)\n        else:\n            opts['data'] = json.dumps(opts['data'])\n        if not url.startswith(self._host):\n            url = urljoin(self._host, url)\n        logger.debug('API %s Request: %s' % (method, url))\n        if debug:\n            self._log_raw_request(method, url, **opts)\n        try:\n            response = self._session.request(method, url, **opts)\n        except Exception as e:\n            _handle_request_error(e)\n        if 429 == response.status_code:\n            delay = int(response.headers['retry-after']) + 1\n            logger.warn('Too many requests. Retrying in {0}s.'.format(delay))\n            time.sleep(delay)\n            return self.request(method, url, **kwargs)\n        if not (200 <= response.status_code < 400):\n            _handle_api_error(response)\n        if raw or response.status_code in [204, 301, 302]:\n            return response\n        return response.json()"
    },
    {
        "code": "def make_default_options_response(self):\n        adapter = _request_ctx_stack.top.url_adapter\n        if hasattr(adapter, 'allowed_methods'):\n            methods = adapter.allowed_methods()\n        else:\n            methods = []\n            try:\n                adapter.match(method='--')\n            except MethodNotAllowed as e:\n                methods = e.valid_methods\n            except HTTPException as e:\n                pass\n        rv = self.response_class()\n        rv.allow.update(methods)\n        return rv"
    },
    {
        "code": "def load(self, path):\n        self.network = graph.Network.load(path)\n        return self.network"
    },
    {
        "code": "def _uri2path(self, uri):\n        if uri == self.package_name:\n            return os.path.join(self.root_path, '__init__.py')\n        path = uri.replace('.', os.path.sep)\n        path = path.replace(self.package_name + os.path.sep, '')\n        path = os.path.join(self.root_path, path)\n        if os.path.exists(path + '.py'):\n            path += '.py'\n        elif os.path.exists(os.path.join(path, '__init__.py')):\n            path = os.path.join(path, '__init__.py')\n        else:\n            return None\n        return path"
    },
    {
        "code": "def describe_object(self, obj):\n        conn = self.get_conn()\n        return conn.__getattr__(obj).describe()"
    },
    {
        "code": "def get_ilvl(li, w_namespace):\n    ilvls = li.xpath('.//w:ilvl', namespaces=li.nsmap)\n    if len(ilvls) == 0:\n        return -1\n    return int(ilvls[0].get('%sval' % w_namespace))"
    },
    {
        "code": "def validateAttrib(self, method, cls = None):\n        any = False\n        for group in self.attribs:\n            match = True\n            for key, value in group:\n                attr = get_method_attr(method, cls, key)\n                if callable(value):\n                    if not value(key, method, cls):\n                        match = False\n                        break\n                elif value is True:\n                    if not bool(attr):\n                        match = False\n                        break\n                elif value is False:\n                    if bool(attr):\n                        match = False\n                        break\n                elif type(attr) in (list, tuple):\n                    if not str(value).lower() in [str(x).lower()\n                                                  for x in attr]:\n                        match = False\n                        break\n                else:\n                    if (value != attr\n                        and str(value).lower() != str(attr).lower()):\n                        match = False\n                        break\n            any = any or match\n        if any:\n            return None\n        return False"
    },
    {
        "code": "def matchmaker_matches(institute_id, case_name):\n    user_obj = store.user(current_user.email)\n    if 'mme_submitter' not in user_obj['roles']:\n        flash('unauthorized request', 'warning')\n        return redirect(request.referrer)\n    mme_base_url = current_app.config.get('MME_URL')\n    mme_token = current_app.config.get('MME_TOKEN')\n    if not mme_base_url or not mme_token:\n        flash('An error occurred reading matchmaker connection parameters. Please check config file!', 'danger')\n        return redirect(request.referrer)\n    institute_obj, case_obj = institute_and_case(store, institute_id, case_name)\n    data = controllers.mme_matches(case_obj, institute_obj, mme_base_url, mme_token)\n    if data and data.get('server_errors'):\n        flash('MatchMaker server returned error:{}'.format(data['server_errors']), 'danger')\n        return redirect(request.referrer)\n    elif not data:\n        data = {\n            'institute' : institute_obj,\n            'case' : case_obj\n        }\n    return data"
    },
    {
        "code": "def get_container(self, name, collection_id, tag=\"latest\", version=None):\n    from sregistry.database.models import Container\n    if version is None:\n        container = Container.query.filter_by(collection_id = collection_id,\n                                              name = name,\n                                              tag = tag).first()\n    else:\n        container = Container.query.filter_by(collection_id = collection_id,\n                                              name = name,\n                                              tag = tag,\n                                              version = version).first()\n    return container"
    },
    {
        "code": "def _plant_trie(strings: _List[str]) -> dict:\n    trie = {}\n    for string in strings:\n        d = trie\n        for char in string:\n            d[char] = char in d and d[char] or {}\n            d = d[char]\n        d[''] = None\n    return trie"
    },
    {
        "code": "def _is_known_unsigned_by_dtype(dt):\n  return {\n      tf.bool: True,\n      tf.uint8: True,\n      tf.uint16: True,\n  }.get(dt.base_dtype, False)"
    },
    {
        "code": "def create_record_and_pid(data):\n    from invenio_records.api import Record\n    from invenio_pidstore.models import PersistentIdentifier, PIDStatus, \\\n        RecordIdentifier\n    deposit = Record.create(data=data)\n    created = arrow.get(data['_p']['created']).datetime\n    deposit.model.created = created.replace(tzinfo=None)\n    depid = deposit['_p']['id']\n    pid = PersistentIdentifier.create(\n        pid_type='depid',\n        pid_value=str(depid),\n        object_type='rec',\n        object_uuid=str(deposit.id),\n        status=PIDStatus.REGISTERED\n    )\n    if RecordIdentifier.query.get(int(depid)) is None:\n        RecordIdentifier.insert(int(depid))\n    deposit.commit()\n    return deposit, pid"
    },
    {
        "code": "def is_embargoed(record):\n    return record.get('access_right') == 'embargoed' and \\\n        record.get('embargo_date') and \\\n        record.get('embargo_date') > datetime.utcnow().date()"
    },
    {
        "code": "def add_comment(self, comment_text):\n        return self.fetch_json(\n            uri_path=self.base_uri + '/actions/comments',\n            http_method='POST',\n            query_params={'text': comment_text}\n        )"
    },
    {
        "code": "def pkt_text(pkt):\n    if pkt.src.upper() in BANNED_DEVICES:\n        body = ''\n    elif pkt.src.upper()[:8] in AMAZON_DEVICES:\n        body = '{} (Amazon Device)'.format(pkt.src)\n    else:\n        body = pkt.src\n    return body"
    },
    {
        "code": "def _update_barrier_status(self):\n        with open(self.log_file) as fh:\n            for line in fh:\n                if \"Session aborted\" in line:\n                    return\n                if \"<<< barrier arrive\" in line:\n                    process_m = re.match(\".*process: (.*)\\)\", line)\n                    if process_m:\n                        process = process_m.group(1)\n                        if process in self.processes:\n                            self.processes[process][\"barrier\"] = \"C\""
    },
    {
        "code": "def copy_notebook(self, notebook_id):\n        last_mod, nb = self.get_notebook_object(notebook_id)\n        name = nb.metadata.name + '-Copy'\n        path, name = self.increment_filename(name)\n        nb.metadata.name = name\n        notebook_id = self.new_notebook_id(name)\n        self.save_notebook_object(notebook_id, nb)\n        return notebook_id"
    },
    {
        "code": "def entity_name_decorator(top_cls):\n    class_name = inflection.underscore(top_cls.__name__).lower()\n    def entity_name(cls):\n        return class_name\n    top_cls.entity_name = classmethod(entity_name)\n    return top_cls"
    },
    {
        "code": "def init_modules(self):\n        if not self.config:\n            raise ValueError(\"please read your config file.\")\n        log.debug(\"begin to import customer's service modules.\")\n        modules = ServiceModules(self.config)\n        modules.import_modules()\n        log.debug(\"end to import customer's service modules.\")"
    },
    {
        "code": "def _normalized(self, data):\n        int_keys = ('frames', 'width', 'height', 'size')\n        for key in int_keys:\n            if key not in data:\n                continue\n            try:\n                data[key] = int(data[key])\n            except ValueError:\n                pass\n        return data"
    },
    {
        "code": "def get_product_by_name(self, name):\n        return next(i for i in self.items if i.name.lower() == name.lower())"
    },
    {
        "code": "def add_point(self, point, value, check=True):\n        if self.tier_type != 'TextTier':\n            raise Exception('Tiertype must be TextTier.')\n        if check and any(i for i in self.intervals if i[0] == point):\n                raise Exception('No overlap is allowed')\n        self.intervals.append((point, value))"
    },
    {
        "code": "def create_adapter(cmph, ffi, obj):\n    if is_file_location(obj):\n        fd = open(obj)\n        adapter = cmph.cmph_io_nlfile_adapter(fd)\n        def dtor():\n            cmph.cmph_io_nlfile_adapter_destroy(adapter)\n            fd.close()\n        return _AdapterCxt(adapter, dtor)\n    elif is_file(obj):\n        adapter = cmph.cmph_io_nlfile_adapter(obj)\n        dtor = lambda: cmph.cmph_io_nlfile_adapter_destroy(adapter)\n        return _AdapterCxt(adapter, dtor)\n    elif isinstance(obj, Sequence):\n        if len(obj) == 0:\n            raise ValueError(\"An empty sequence is already a perfect hash!\")\n        return _create_pyobj_adapter(cmph, ffi, obj)\n    else:\n        raise ValueError(\"data cannot have a cmph wrapper generated\")"
    },
    {
        "code": "def _hash_file(self, algo):\n        hash_data = getattr(hashlib, algo)()\n        with open(self.path, \"rb\") as file:\n            content = file.read()\n            hash_data.update(content)\n        return hash_data.hexdigest()"
    },
    {
        "code": "def to_string(self, indent):\n        ind = indent * ' '\n        print(ind, 'qreg')\n        self.children[0].to_string(indent + 3)"
    },
    {
        "code": "def _installation_trace(self, frame_unused, event_unused, arg_unused):\n        sys.settrace(None)\n        fn = self._start_tracer()\n        if fn:\n            fn = fn(frame_unused, event_unused, arg_unused)\n        return fn"
    },
    {
        "code": "def parse_sv_frequencies(variant):\n    frequency_keys = [\n        'clingen_cgh_benignAF',\n        'clingen_cgh_benign',\n        'clingen_cgh_pathogenicAF',\n        'clingen_cgh_pathogenic',\n        'clingen_ngi',\n        'clingen_ngiAF',\n        'swegen',\n        'swegenAF',\n        'decipherAF',\n        'decipher'\n    ]\n    sv_frequencies = {}\n    for key in frequency_keys:\n        value = variant.INFO.get(key, 0)\n        if 'AF' in key:\n            value = float(value)\n        else:\n            value = int(value)\n        if value > 0:\n            sv_frequencies[key] = value\n    return sv_frequencies"
    },
    {
        "code": "def calc_fwhm(distribution, is_neg_log=True):\n        if isinstance(distribution, interp1d):\n            if is_neg_log:\n                ymin = distribution.y.min()\n                log_prob = distribution.y-ymin\n            else:\n                log_prob = -np.log(distribution.y)\n                log_prob -= log_prob.min()\n            xvals = distribution.x\n        elif isinstance(distribution, Distribution):\n            xvals = distribution._func.x\n            log_prob = distribution._func.y\n        else:\n            raise TypeError(\"Error in computing the FWHM for the distribution. \"\n                \" The input should be either Distribution or interpolation object\");\n        L = xvals.shape[0]\n        tmp = np.where(log_prob < 0.693147)[0]\n        x_l, x_u = tmp[0], tmp[-1]\n        if L < 2:\n            print (\"Not enough points to compute FWHM: returning zero\")\n            return min(TINY_NUMBER, distribution.xmax - distribution.xmin)\n        else:\n            return max(TINY_NUMBER, xvals[min(x_u+1,L-1)] - xvals[max(0,x_l-1)])"
    },
    {
        "code": "def submit_order(self, symbol, qty, side, type, time_in_force,\n                     limit_price=None, stop_price=None, client_order_id=None):\n        params = {\n            'symbol': symbol,\n            'qty': qty,\n            'side': side,\n            'type': type,\n            'time_in_force': time_in_force,\n        }\n        if limit_price is not None:\n            params['limit_price'] = limit_price\n        if stop_price is not None:\n            params['stop_price'] = stop_price\n        if client_order_id is not None:\n            params['client_order_id'] = client_order_id\n        resp = self.post('/orders', params)\n        return Order(resp)"
    },
    {
        "code": "def get_queryset(self):\n        queryset = self.get_publishable_queryset()\n        queryset = queryset \\\n            .select_related('featured_image', 'featured_video', 'topic', 'section', 'subsection') \\\n            .prefetch_related(\n                'tags',\n                'featured_image__image__authors',\n                'authors'\n            )\n        queryset = queryset.order_by('-updated_at')\n        q = self.request.query_params.get('q', None)\n        section = self.request.query_params.get('section', None)\n        tags = self.request.query_params.getlist('tags', None)\n        author = self.request.query_params.get('author', None)\n        if q is not None:\n            queryset = queryset.filter(headline__icontains=q)\n        if section is not None:\n            queryset = queryset.filter(section_id=section)\n        if tags is not None:\n            for tag in tags:\n                queryset = queryset.filter(tags__id=tag)\n        if author is not None:\n            queryset = queryset.filter(authors__person_id=author)\n        return queryset"
    },
    {
        "code": "def get_instance_group_manager(self, zone, resource_id, project_id=None):\n        response = self.get_conn().instanceGroupManagers().get(\n            project=project_id,\n            zone=zone,\n            instanceGroupManager=resource_id\n        ).execute(num_retries=self.num_retries)\n        return response"
    },
    {
        "code": "def get_contacts(address_books, query, method=\"all\", reverse=False,\n                 group=False, sort=\"first_name\"):\n    contacts = []\n    for address_book in address_books:\n        contacts.extend(address_book.search(query, method=method))\n    if group:\n        if sort == \"first_name\":\n            return sorted(contacts, reverse=reverse, key=lambda x: (\n                unidecode(x.address_book.name).lower(),\n                unidecode(x.get_first_name_last_name()).lower()))\n        elif sort == \"last_name\":\n            return sorted(contacts, reverse=reverse, key=lambda x: (\n                unidecode(x.address_book.name).lower(),\n                unidecode(x.get_last_name_first_name()).lower()))\n        else:\n            raise ValueError('sort must be \"first_name\" or \"last_name\" not '\n                             '{}.'.format(sort))\n    else:\n        if sort == \"first_name\":\n            return sorted(contacts, reverse=reverse, key=lambda x:\n                          unidecode(x.get_first_name_last_name()).lower())\n        elif sort == \"last_name\":\n            return sorted(contacts, reverse=reverse, key=lambda x:\n                          unidecode(x.get_last_name_first_name()).lower())\n        else:\n            raise ValueError('sort must be \"first_name\" or \"last_name\" not '\n                             '{}.'.format(sort))"
    },
    {
        "code": "def remove_property(self, property_):\n        if property_.name in self.properties:\n            del self.properties[property_.name]"
    },
    {
        "code": "def delete(self, filename=None):\n        if filename is None:\n            filename = self.filename\n        delete(filename)\n        self.clear()"
    },
    {
        "code": "def DeleteAllItems(self):\r\n        \"Remove all the item from the list and unset the related data\"\r\n        self._py_data_map.clear()\r\n        self._wx_data_map.clear()\r\n        wx.ListCtrl.DeleteAllItems(self)"
    },
    {
        "code": "def phone_subcommand(search_terms, vcard_list, parsable):\n    all_phone_numbers_list = []\n    matching_phone_number_list = []\n    for vcard in vcard_list:\n        for type, number_list in sorted(vcard.get_phone_numbers().items(),\n                                        key=lambda k: k[0].lower()):\n            for number in sorted(number_list):\n                if config.display_by_name() == \"first_name\":\n                    name = vcard.get_first_name_last_name()\n                else:\n                    name = vcard.get_last_name_first_name()\n                line_formatted = \"\\t\".join([name, type, number])\n                line_parsable = \"\\t\".join([number, name, type])\n                if parsable:\n                    phone_number_line = line_parsable\n                else:\n                    phone_number_line = line_formatted\n                if re.search(search_terms,\n                             \"%s\\n%s\" % (line_formatted, line_parsable),\n                             re.IGNORECASE | re.DOTALL):\n                    matching_phone_number_list.append(phone_number_line)\n                elif len(re.sub(\"\\D\", \"\", search_terms)) >= 3:\n                    if re.search(re.sub(\"\\D\", \"\", search_terms),\n                                 re.sub(\"\\D\", \"\", number), re.IGNORECASE):\n                        matching_phone_number_list.append(phone_number_line)\n                all_phone_numbers_list.append(phone_number_line)\n    if matching_phone_number_list:\n        if parsable:\n            print('\\n'.join(matching_phone_number_list))\n        else:\n            list_phone_numbers(matching_phone_number_list)\n    elif all_phone_numbers_list:\n        if parsable:\n            print('\\n'.join(all_phone_numbers_list))\n        else:\n            list_phone_numbers(all_phone_numbers_list)\n    else:\n        if not parsable:\n            print(\"Found no phone numbers\")\n        sys.exit(1)"
    },
    {
        "code": "def add_and_rename_file(self, filename: str, new_filename: str) -> None:\n        dest = os.path.join(\n            self.name + ':' + SANDBOX_WORKING_DIR_NAME,\n            new_filename)\n        subprocess.check_call(['docker', 'cp', filename, dest])\n        self._chown_files([new_filename])"
    },
    {
        "code": "def parse_frequencies(variant, transcripts):\n    frequencies = {}\n    thousand_genomes_keys = ['1000GAF']\n    thousand_genomes_max_keys = ['1000G_MAX_AF']\n    exac_keys = ['EXACAF']\n    exac_max_keys = ['ExAC_MAX_AF', 'EXAC_MAX_AF']\n    gnomad_keys = ['GNOMADAF', 'GNOMAD_AF']\n    gnomad_max_keys = ['GNOMADAF_POPMAX', 'GNOMADAF_MAX']\n    for test_key in thousand_genomes_keys:\n        thousand_g = parse_frequency(variant, test_key)\n        if thousand_g:\n            frequencies['thousand_g'] = thousand_g\n            break\n    for test_key in thousand_genomes_max_keys:\n        thousand_g_max = parse_frequency(variant, test_key)\n        if thousand_g_max:\n            frequencies['thousand_g_max'] = thousand_g_max\n            break\n    for test_key in exac_keys:\n        exac = parse_frequency(variant, test_key)\n        if exac:\n            frequencies['exac'] = exac\n            break\n    for test_key in exac_max_keys:\n        exac_max = parse_frequency(variant, test_key)\n        if exac_max:\n            frequencies['exac_max'] = exac_max\n            break\n    for test_key in gnomad_keys:\n        gnomad = parse_frequency(variant, test_key)\n        if gnomad:\n            frequencies['gnomad'] = gnomad\n            break\n    for test_key in gnomad_max_keys:\n        gnomad_max = parse_frequency(variant, test_key)\n        if gnomad_max:\n            frequencies['gnomad_max'] = gnomad_max\n            break\n    if not frequencies:\n        for transcript in transcripts:\n            exac = transcript.get('exac_maf')\n            exac_max = transcript.get('exac_max')\n            thousand_g = transcript.get('thousand_g_maf')\n            thousandg_max = transcript.get('thousandg_max')\n            gnomad = transcript.get('gnomad_maf')\n            gnomad_max = transcript.get('gnomad_max')\n            if exac:\n                frequencies['exac'] = exac\n            if exac_max:\n                frequencies['exac_max'] = exac_max\n            if thousand_g:\n                frequencies['thousand_g'] = thousand_g\n            if thousandg_max:\n                frequencies['thousand_g_max'] = thousandg_max\n            if gnomad:\n                frequencies['gnomad'] = gnomad\n            if gnomad_max:\n                frequencies['gnomad_max'] = gnomad_max\n    thousand_g_left = parse_frequency(variant, 'left_1000GAF')\n    if thousand_g_left:\n        frequencies['thousand_g_left'] = thousand_g_left\n    thousand_g_right = parse_frequency(variant, 'right_1000GAF')\n    if thousand_g_right:\n        frequencies['thousand_g_right'] = thousand_g_right\n    return frequencies"
    },
    {
        "code": "def random(cls, num_qubits, seed=None):\n        if seed is not None:\n            np.random.seed(seed)\n        z = np.random.randint(2, size=num_qubits).astype(np.bool)\n        x = np.random.randint(2, size=num_qubits).astype(np.bool)\n        return cls(z, x)"
    },
    {
        "code": "def lost_dimensions(point_fmt_in, point_fmt_out):\n    unpacked_dims_in = PointFormat(point_fmt_in).dtype\n    unpacked_dims_out = PointFormat(point_fmt_out).dtype\n    out_dims = unpacked_dims_out.fields\n    completely_lost = []\n    for dim_name in unpacked_dims_in.names:\n        if dim_name not in out_dims:\n            completely_lost.append(dim_name)\n    return completely_lost"
    },
    {
        "code": "def rename(script, label='blank', layer_num=None):\n    filter_xml = ''.join([\n        '  <filter name=\"Rename Current Mesh\">\\n',\n        '    <Param name=\"newName\" ',\n        'value=\"{}\" '.format(label),\n        'description=\"New Label\" ',\n        'type=\"RichString\" ',\n        '/>\\n',\n        '  </filter>\\n'])\n    if isinstance(script, mlx.FilterScript):\n        if (layer_num is None) or (layer_num == script.current_layer()):\n            util.write_filter(script, filter_xml)\n            script.layer_stack[script.current_layer()] = label\n        else:\n            cur_layer = script.current_layer()\n            change(script, layer_num)\n            util.write_filter(script, filter_xml)\n            change(script, cur_layer)\n            script.layer_stack[layer_num] = label\n    else:\n        util.write_filter(script, filter_xml)\n    return None"
    },
    {
        "code": "def verify_signature(amazon_cert: crypto.X509, signature: str, request_body: bytes) -> bool:\n    signature = base64.b64decode(signature)\n    try:\n        crypto.verify(amazon_cert, signature, request_body, 'sha1')\n        result = True\n    except crypto.Error:\n        result = False\n    return result"
    },
    {
        "code": "def parallel_execute(self, cell, block=None, groupby='type', save_name=None):\n        block = self.view.block if block is None else block\n        base = \"Parallel\" if block else \"Async parallel\"\n        targets = self.view.targets\n        if isinstance(targets, list) and len(targets) > 10:\n            str_targets = str(targets[:4])[:-1] + ', ..., ' + str(targets[-4:])[1:]\n        else:\n            str_targets = str(targets)\n        if self.verbose:\n            print base + \" execution on engine(s): %s\" % str_targets\n        result = self.view.execute(cell, silent=False, block=False)\n        self.last_result = result\n        if save_name:\n            self.shell.user_ns[save_name] = result\n        if block:\n            result.get()\n            result.display_outputs(groupby)\n        else:\n            return result"
    },
    {
        "code": "def class_is_abstract(node: astroid.ClassDef) -> bool:\n    for method in node.methods():\n        if method.parent.frame() is node:\n            if method.is_abstract(pass_is_abstract=False):\n                return True\n    return False"
    },
    {
        "code": "def _merge_statements(statements: List[\"HdlStatement\"])\\\n            -> Tuple[List[\"HdlStatement\"], int]:\n        order = {}\n        for i, stm in enumerate(statements):\n            order[stm] = i\n        new_statements = []\n        rank_decrease = 0\n        for rank, stms in groupedby(statements, lambda s: s.rank):\n            if rank == 0:\n                new_statements.extend(stms)\n            else:\n                if len(stms) == 1:\n                    new_statements.extend(stms)\n                    continue\n                for iA, stmA in enumerate(stms):\n                    if stmA is None:\n                        continue\n                    for iB, stmB in enumerate(islice(stms, iA + 1, None)):\n                        if stmB is None:\n                            continue\n                        if stmA._is_mergable(stmB):\n                            rank_decrease += stmB.rank\n                            stmA._merge_with_other_stm(stmB)\n                            stms[iA + 1 + iB] = None\n                            new_statements.append(stmA)\n                        else:\n                            new_statements.append(stmA)\n                            new_statements.append(stmB)\n        new_statements.sort(key=lambda stm: order[stm])\n        return new_statements, rank_decrease"
    },
    {
        "code": "def convert(self, value):\n        if not isinstance(value, ConvertingDict) and isinstance(value, dict):\n            value = ConvertingDict(value)\n            value.configurator = self\n        elif not isinstance(value, ConvertingList) and isinstance(value, list):\n            value = ConvertingList(value)\n            value.configurator = self\n        elif not isinstance(value, ConvertingTuple) and\\\n                 isinstance(value, tuple):\n            value = ConvertingTuple(value)\n            value.configurator = self\n        elif isinstance(value, six.string_types):\n            m = self.CONVERT_PATTERN.match(value)\n            if m:\n                d = m.groupdict()\n                prefix = d['prefix']\n                converter = self.value_converters.get(prefix, None)\n                if converter:\n                    suffix = d['suffix']\n                    converter = getattr(self, converter)\n                    value = converter(suffix)\n        return value"
    },
    {
        "code": "def bind_parameter(binding_key, value):\n  if config_is_locked():\n    raise RuntimeError('Attempted to modify locked Gin config.')\n  pbk = ParsedBindingKey(binding_key)\n  fn_dict = _CONFIG.setdefault(pbk.config_key, {})\n  fn_dict[pbk.arg_name] = value"
    },
    {
        "code": "def verify_signature(self,\n                         signing_key,\n                         message,\n                         signature,\n                         padding_method,\n                         signing_algorithm=None,\n                         hashing_algorithm=None,\n                         digital_signature_algorithm=None):\n        backend = default_backend()\n        hash_algorithm = None\n        dsa_hash_algorithm = None\n        dsa_signing_algorithm = None\n        if hashing_algorithm:\n            hash_algorithm = self._encryption_hash_algorithms.get(\n                hashing_algorithm\n            )\n        if digital_signature_algorithm:\n            algorithm_pair = self._digital_signature_algorithms.get(\n                digital_signature_algorithm\n            )\n            if algorithm_pair:\n                dsa_hash_algorithm = algorithm_pair[0]\n                dsa_signing_algorithm = algorithm_pair[1]\n        if dsa_hash_algorithm and dsa_signing_algorithm:\n            if hash_algorithm and (hash_algorithm != dsa_hash_algorithm):\n                raise exceptions.InvalidField(\n                    \"The hashing algorithm does not match the digital \"\n                    \"signature algorithm.\"\n                )\n            if (signing_algorithm and\n                    (signing_algorithm != dsa_signing_algorithm)):\n                raise exceptions.InvalidField(\n                    \"The signing algorithm does not match the digital \"\n                    \"signature algorithm.\"\n                )\n            signing_algorithm = dsa_signing_algorithm\n            hash_algorithm = dsa_hash_algorithm\n        if signing_algorithm == enums.CryptographicAlgorithm.RSA:\n            if padding_method == enums.PaddingMethod.PSS:\n                if hash_algorithm:\n                    padding = asymmetric_padding.PSS(\n                        mgf=asymmetric_padding.MGF1(hash_algorithm()),\n                        salt_length=asymmetric_padding.PSS.MAX_LENGTH\n                    )\n                else:\n                    raise exceptions.InvalidField(\n                        \"A hashing algorithm must be specified for PSS \"\n                        \"padding.\"\n                    )\n            elif padding_method == enums.PaddingMethod.PKCS1v15:\n                padding = asymmetric_padding.PKCS1v15()\n            else:\n                raise exceptions.InvalidField(\n                    \"The padding method '{0}' is not supported for signature \"\n                    \"verification.\".format(padding_method)\n                )\n            try:\n                public_key = backend.load_der_public_key(signing_key)\n            except Exception:\n                try:\n                    public_key = backend.load_pem_public_key(signing_key)\n                except Exception:\n                    raise exceptions.CryptographicFailure(\n                        \"The signing key bytes could not be loaded.\"\n                    )\n            try:\n                public_key.verify(\n                    signature,\n                    message,\n                    padding,\n                    hash_algorithm()\n                )\n                return True\n            except errors.InvalidSignature:\n                return False\n            except Exception:\n                raise exceptions.CryptographicFailure(\n                    \"The signature verification process failed.\"\n                )\n        else:\n            raise exceptions.InvalidField(\n                \"The signing algorithm '{0}' is not supported for \"\n                \"signature verification.\".format(signing_algorithm)\n            )"
    },
    {
        "code": "def predict(self, x, distributed=True):\n        if is_distributed:\n            if isinstance(x, np.ndarray):\n                features = to_sample_rdd(x, np.zeros([x.shape[0]]))\n            elif isinstance(x, RDD):\n                features = x\n            else:\n                raise TypeError(\"Unsupported prediction data type: %s\" % type(x))\n            return self.predict_distributed(features)\n        else:\n            if isinstance(x, np.ndarray):\n                return self.predict_local(x)\n            else:\n                raise TypeError(\"Unsupported prediction data type: %s\" % type(x))"
    },
    {
        "code": "def generate(self, outputfile=None, dotfile=None, mapfile=None):\n        import subprocess\n        name = self.graphname\n        if not dotfile:\n            if outputfile and outputfile.endswith(\".dot\"):\n                dotfile = outputfile\n            else:\n                dotfile = \"%s.dot\" % name\n        if outputfile is not None:\n            storedir, _, target = target_info_from_filename(outputfile)\n            if target != \"dot\":\n                pdot, dot_sourcepath = tempfile.mkstemp(\".dot\", name)\n                os.close(pdot)\n            else:\n                dot_sourcepath = osp.join(storedir, dotfile)\n        else:\n            target = \"png\"\n            pdot, dot_sourcepath = tempfile.mkstemp(\".dot\", name)\n            ppng, outputfile = tempfile.mkstemp(\".png\", name)\n            os.close(pdot)\n            os.close(ppng)\n        pdot = codecs.open(dot_sourcepath, \"w\", encoding=\"utf8\")\n        pdot.write(self.source)\n        pdot.close()\n        if target != \"dot\":\n            use_shell = sys.platform == \"win32\"\n            if mapfile:\n                subprocess.call(\n                    [\n                        self.renderer,\n                        \"-Tcmapx\",\n                        \"-o\",\n                        mapfile,\n                        \"-T\",\n                        target,\n                        dot_sourcepath,\n                        \"-o\",\n                        outputfile,\n                    ],\n                    shell=use_shell,\n                )\n            else:\n                subprocess.call(\n                    [self.renderer, \"-T\", target, dot_sourcepath, \"-o\", outputfile],\n                    shell=use_shell,\n                )\n            os.unlink(dot_sourcepath)\n        return outputfile"
    },
    {
        "code": "def connect(com, peers, tree, pub_url, root_id):\n    com.connect(peers, tree, pub_url, root_id)"
    },
    {
        "code": "def delete_instance(self, instance_id, project_id=None):\n        instance = self.get_instance(instance_id=instance_id, project_id=project_id)\n        if instance:\n            instance.delete()\n        else:\n            self.log.info(\"The instance '%s' does not exist in project '%s'. Exiting\", instance_id,\n                          project_id)"
    },
    {
        "code": "def encode(self, input, errors='strict'):\n        if isinstance(input, memoryview):\n            input = input.tobytes()\n        if not isinstance(input, (binary_type, bytearray)):\n            raise with_context(\n                exc=TypeError(\n                    \"Can't encode {type}; byte string expected.\".format(\n                        type=type(input).__name__,\n                    )),\n                context={\n                    'input': input,\n                },\n            )\n        if not isinstance(input, bytearray):\n            input = bytearray(input)\n        trytes = bytearray()\n        for c in input:\n            second, first = divmod(c, len(self.alphabet))\n            trytes.append(self.alphabet[first])\n            trytes.append(self.alphabet[second])\n        return binary_type(trytes), len(input)"
    },
    {
        "code": "def get_hash(\n            cls,\n            version: str,\n            frequency: int,\n            timestamp: int,\n            seed_value: str,\n            prev_output: str,\n            status_code: str,\n    ) -> SHA512Hash:\n        return SHA512.new(\n            version.encode() +\n            struct.pack(\n                '>1I1Q64s64s1I',\n                frequency,\n                timestamp,\n                binascii.a2b_hex(seed_value),\n                binascii.a2b_hex(prev_output),\n                int(status_code),\n            )\n        )"
    },
    {
        "code": "def init(\n    dist='dist',\n    minver=None,\n    maxver=None,\n    use_markdown_readme=True,\n    use_stdeb=False,\n    use_distribute=False,\n    ):\n    if not minver == maxver == None:\n        import sys\n        if not minver <= sys.version < (maxver or 'Any'):\n            sys.stderr.write(\n                '%s: requires python version in <%s, %s), not %s\\n' % (\n                sys.argv[0], minver or 'any', maxver or 'any', sys.version.split()[0]))\n            sys.exit(1)\n    if use_distribute:\n        from distribute_setup import use_setuptools\n        use_setuptools(to_dir=dist)\n        from setuptools import setup\n    else:\n        try:\n            from setuptools import setup\n        except ImportError:\n            from distutils.core import setup\n    if use_markdown_readme:\n        try:\n            import setuptools.command.sdist\n            setuptools.command.sdist.READMES = tuple(list(getattr(setuptools.command.sdist, 'READMES', ()))\n                + ['README.md'])\n        except ImportError:\n            pass\n    if use_stdeb:\n        import platform\n        if 'debian' in platform.dist():\n            try:\n                import stdeb\n            except ImportError:\n                pass\n    return setup"
    },
    {
        "code": "def get_defined_srms(srm_file):\n    srms = read_table(srm_file)\n    return np.asanyarray(srms.index.unique())"
    },
    {
        "code": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_2_0):\n        if kmip_version < enums.KMIPVersion.KMIP_2_0:\n            raise exceptions.VersionNotSupported(\n                \"KMIP {} does not support the DefaultsInformation \"\n                \"object.\".format(\n                    kmip_version.value\n                )\n            )\n        super(DefaultsInformation, self).read(\n            input_buffer,\n            kmip_version=kmip_version\n        )\n        local_buffer = utils.BytearrayStream(input_buffer.read(self.length))\n        object_defaults = []\n        while self.is_tag_next(enums.Tags.OBJECT_DEFAULTS, local_buffer):\n            object_default = ObjectDefaults()\n            object_default.read(local_buffer, kmip_version=kmip_version)\n            object_defaults.append(object_default)\n        if len(object_defaults) == 0:\n            raise exceptions.InvalidKmipEncoding(\n                \"The DefaultsInformation encoding is missing the object \"\n                \"defaults structure.\"\n            )\n        else:\n            self._object_defaults = object_defaults\n        self.is_oversized(local_buffer)"
    },
    {
        "code": "def unused_variable_line_numbers(messages):\n    for message in messages:\n        if isinstance(message, pyflakes.messages.UnusedVariable):\n            yield message.lineno"
    },
    {
        "code": "def set_data(data):\n    \"Write content to the clipboard, data can be either a string or a bitmap\" \n    try:\n        if wx.TheClipboard.Open():\n            if isinstance(data, (str, unicode)):\n                do = wx.TextDataObject()\n                do.SetText(data)\n                wx.TheClipboard.SetData(do)\n            elif isinstance(data, wx.Bitmap):\n                do = wx.BitmapDataObject()\n                do.SetBitmap(data)\n                wx.TheClipboard.SetData(do)\n            wx.TheClipboard.Close()\n    except:\n        pass"
    },
    {
        "code": "def partial(f, *args):\n    @functools.wraps(f)\n    def partial_f(*inner_args):\n        return f(*itertools.chain(args, inner_args))\n    return partial_f"
    },
    {
        "code": "def match(self, request):\n        errors = []\n        def match(matcher):\n            try:\n                return matcher.match(request)\n            except Exception as err:\n                err = '{}: {}'.format(type(matcher).__name__, err)\n                errors.append(err)\n                return False\n        return all([match(matcher) for matcher in self]), errors"
    },
    {
        "code": "def batch_shape_tensor(self):\n    batch_shape = tf.constant([], dtype=tf.int32)\n    for param in self.parameters:\n      batch_shape = tf.broadcast_dynamic_shape(\n          batch_shape, param.prior.batch_shape_tensor())\n    return batch_shape"
    },
    {
        "code": "def generate(self, *arg, **kw):\n        for p, meth in self.plugins:\n            result = None\n            try:\n                result = meth(*arg, **kw)\n                if result is not None:\n                    for r in result:\n                        yield r\n            except (KeyboardInterrupt, SystemExit):\n                raise\n            except:\n                exc = sys.exc_info()\n                yield Failure(*exc)\n                continue"
    },
    {
        "code": "def fracpols(str, **kwargs):\n    I,Q,U,V,L=get_stokes(str, **kwargs)\n    return L/I,V/I"
    },
    {
        "code": "def checkUser(self, user):\n        return not self.conn(\"POST\", \"{0}/GetCredentialType.srf\".format(SkypeConnection.API_MSACC),\n                             json={\"username\": user}).json().get(\"IfExistsResult\")"
    },
    {
        "code": "def user_institutes(store, login_user):\n    if login_user.is_admin:\n        institutes = store.institutes()\n    else:\n        institutes = [store.institute(inst_id) for inst_id in login_user.institutes]\n    return institutes"
    },
    {
        "code": "def start(self, job):\n        if self.hostname is None:\n            self.hostname = subprocess.check_output([\"hostname\", \"-f\",])[:-1]\n        _log.info(\"Started Spark master container.\")\n        self.sparkContainerID = dockerCheckOutput(job=job,\n                                                  defer=STOP,\n                                                  workDir=os.getcwd(),\n                                                  tool=\"quay.io/ucsc_cgl/apache-spark-master:1.5.2\",\n                                                  dockerParameters=[\"--net=host\",\n                                                                    \"-d\",\n                                                                    \"-v\", \"/mnt/ephemeral/:/ephemeral/:rw\",\n                                                                    \"-e\", \"SPARK_MASTER_IP=\" + self.hostname,\n                                                                    \"-e\", \"SPARK_LOCAL_DIRS=/ephemeral/spark/local\",\n                                                                    \"-e\", \"SPARK_WORKER_DIR=/ephemeral/spark/work\"],\n                                                  parameters=[self.hostname])[:-1]\n        _log.info(\"Started HDFS Datanode.\")\n        self.hdfsContainerID = dockerCheckOutput(job=job,\n                                           defer=STOP,\n                                           workDir=os.getcwd(),\n                                           tool=\"quay.io/ucsc_cgl/apache-hadoop-master:2.6.2\",\n                                           dockerParameters=[\"--net=host\",\n                                                              \"-d\"],\n                                           parameters=[self.hostname])[:-1]\n        return self.hostname"
    },
    {
        "code": "def sequence_LH(self, pos=None, full_sequence=False):\n        if not hasattr(self.tree, \"total_sequence_LH\"):\n            self.logger(\"TreeAnc.sequence_LH: you need to run marginal ancestral inference first!\", 1)\n            self.infer_ancestral_sequences(marginal=True)\n        if pos is not None:\n            if full_sequence:\n                compressed_pos = self.full_to_reduced_sequence_map[pos]\n            else:\n                compressed_pos = pos\n            return self.tree.sequence_LH[compressed_pos]\n        else:\n            return self.tree.total_sequence_LH"
    },
    {
        "code": "def adjust_saturation(img, saturation_factor):\n    if not _is_pil_image(img):\n        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n    enhancer = ImageEnhance.Color(img)\n    img = enhancer.enhance(saturation_factor)\n    return img"
    },
    {
        "code": "def issue_funds(ctx, amount='uint256', rtgs_hash='bytes32', returns=STATUS):\n        \"In the IOU fungible the supply is set by Issuer, who issue funds.\"\n        ctx.accounts[ctx.msg_sender] += amount\n        ctx.issued_amounts[ctx.msg_sender] += amount\n        ctx.Issuance(ctx.msg_sender, rtgs_hash, amount)\n        return OK"
    },
    {
        "code": "def build_seasonal_transition_noise(\n    drift_scale, num_seasons, is_last_day_of_season):\n  drift_scale_diag = tf.stack(\n      [tf.zeros_like(drift_scale)] * (num_seasons - 1) + [drift_scale],\n      axis=-1)\n  def seasonal_transition_noise(t):\n    noise_scale_diag = dist_util.pick_scalar_condition(\n        is_last_day_of_season(t),\n        drift_scale_diag,\n        tf.zeros_like(drift_scale_diag))\n    return tfd.MultivariateNormalDiag(\n        loc=tf.zeros(num_seasons, dtype=drift_scale.dtype),\n        scale_diag=noise_scale_diag)\n  return seasonal_transition_noise"
    },
    {
        "code": "def resolve_url(self, url, follow_redirect=True):\n        url = update_scheme(\"http://\", url)\n        available_plugins = []\n        for name, plugin in self.plugins.items():\n            if plugin.can_handle_url(url):\n                available_plugins.append(plugin)\n        available_plugins.sort(key=lambda x: x.priority(url), reverse=True)\n        if available_plugins:\n            return available_plugins[0](url)\n        if follow_redirect:\n            try:\n                res = self.http.head(url, allow_redirects=True, acceptable_status=[501])\n                if res.status_code == 501:\n                    res = self.http.get(url, stream=True)\n                if res.url != url:\n                    return self.resolve_url(res.url, follow_redirect=follow_redirect)\n            except PluginError:\n                pass\n        raise NoPluginError"
    },
    {
        "code": "def embed_font_to_svg(filepath, outfile, font_files):\n    tree = _embed_font_to_svg(filepath, font_files)\n    tree.write(outfile, encoding='utf-8', pretty_print=True)"
    },
    {
        "code": "def verify_type_product(self, satellite):\n        if satellite == 'L5':\n            id_satellite = '3119'\n            stations = ['GLC', 'ASA', 'KIR', 'MOR', 'KHC', 'PAC', 'KIS', 'CHM', 'LGS', 'MGR', 'COA', 'MPS']\n        elif satellite == 'L7':\n            id_satellite = '3373'\n            stations = ['EDC', 'SGS', 'AGS', 'ASN', 'SG1']\n        elif satellite == 'L8':\n            id_satellite = '4923'\n            stations = ['LGN']\n        else:\n            raise ProductInvalidError('Type product invalid. the permitted types are: L5, L7, L8. ')\n        typ_product = dict(id_satelite=id_satellite, stations=stations)\n        return typ_product"
    },
    {
        "code": "def brent(seqs, f=None, start=None, key=lambda x: x):\n    power = period = 1\n    tortise, hare = seqs\n    yield hare.next()\n    tortise_value = tortise.next()\n    hare_value = hare.next()\n    while key(tortise_value) != key(hare_value):\n        yield hare_value\n        if power == period:\n            power *= 2\n            period = 0\n            if f:\n                tortise = f_generator(f, hare_value)\n                tortise_value = tortise.next()\n            else:\n                while tortise_value != hare_value:\n                    tortise_value = tortise.next()\n        hare_value = hare.next()\n        period += 1\n    if f is None:\n        raise CycleDetected()\n    first = 0\n    tortise_value = hare_value = start\n    for _ in xrange(period):\n        hare_value = f(hare_value)\n    while key(tortise_value) != key(hare_value):\n        tortise_value = f(tortise_value)\n        hare_value = f(hare_value)\n        first += 1\n    raise CycleDetected(period=period, first=first)"
    },
    {
        "code": "def add_s(self, s, obj, priority= 0 ):\n        chain = self.strs.get(s, CommandChainDispatcher())\n        chain.add(obj,priority)\n        self.strs[s] = chain"
    }
]