generations/gen_v3_csn600.jsonl

{"i": 0, "got": "def __msgc_step3_discontinuity_localization(self):\n    \"\"\"pass\"\"\"\n    import scipy\n    start = self._start_time\n    seg = 1 - self.segmentation.astype(np.int8)\n    self.stats['low level object voxels'] = np.sum(seg)\n    self.stats['low level image voxels'] = np.prod(seg.shape)\n    seg_border = scipy.ndimage.filters.laplace(seg, mode='constant')\n    logger.debug('seg_border: %s', scipy.stats.describe(seg_border, axis=None))\n    seg_border[seg_border != 0] = 1\n    logger.debug('seg_border: %s', scipy.stats.describe(seg_border, axis=None))\n    boundary_dilatation_distance = self.segparams['boundary_dilatation_distance']\n    seg = scipy.ndimage.morphology.binary_dilation(seg_border, np.ones([boundary_dilatation_distance * 2 + 1, boundary_dilatation_distance * 2 + 1, boundary_dilatation_distance * 2 + 1]))\n    if self.keep_temp_properties:\n        self.temp_msgc_lowres_discontinuity = seg\n    else:\n        self.temp_msgc_lowres_discontinuity = None\n    if self.debug_images:\n        import sed3\n        pd = sed3.sed3(seg_border)\n        pd.show()\n        pd = sed3.sed3(seg)\n        pd.show()\n    self.stats['t3'] = time.time() - start\n    return seg"}
{"i": 1, "got": "def __multiscale_gc_lo2hi_run(self):\n    \"\"\"pass\"\"\"\n    self._msgc_lo2hi_resize_init()\n    self.__msgc_step0_init()\n    hard_constraints = self.__msgc_step12_low_resolution_segmentation()\n    seg = self.__msgc_step3_discontinuity_localization()\n    self.stats['t3.1'] = time.time() - self._start_time\n    graph = Graph(seg, voxelsize=self.voxelsize, nsplit=self.segparams['block_size'], edge_weight_table=self._msgc_npenalty_table, compute_low_nodes_index=True)\n    graph.generate_base_grid()\n    self.stats['t3.2'] = time.time() - self._start_time\n    graph.split_voxels()\n    self.stats['t3.3'] = time.time() - self._start_time\n    self.stats.update(graph.stats)\n    self.stats['t4'] = time.time() - self._start_time\n    mul_mask, mul_val = self.__msgc_tlinks_area_weight_from_low_segmentation(seg)\n    area_weight = 1\n    unariesalt = self.__create_tlinks(self.img, self.voxelsize, self.seeds, area_weight=area_weight, hard_constraints=hard_constraints, mul_mask=None, mul_val=None)\n    self.stats['t5'] = time.time() - self._start_time\n    un, ind = np.unique(graph.msinds, return_index=True)\n    self.stats['t6'] = time.time() - self._start_time\n    self.stats['t7'] = time.time() - self._start_time\n    unariesalt2_lo2hi = np.hstack([unariesalt[ind, 0, 0].reshape(-1, 1), unariesalt[ind, 0, 1].reshape(-1, 1)])\n    nlinks_lo2hi = np.hstack([graph.edges, graph.edges_weights.reshape(-1, 1)])\n    if self.debug_images:\n        import sed3\n        ed = sed3.sed3(unariesalt[:, :, 0].reshape(self.img.shape))\n        ed.show()\n        import sed3\n        ed = sed3.sed3(unariesalt[:, :, 1].reshape(self.img.shape))\n        ed.show()\n    self.__msgc_step9_finish_perform_gc_and_reshape(nlinks_lo2hi, unariesalt2_lo2hi, graph.msinds)\n    self._msgc_lo2hi_resize_clean_finish()"}
{"i": 2, "got": "def __multiscale_gc_hi2lo_run(self):\n    \"\"\"pass\"\"\"\n    self.__msgc_step0_init()\n    hard_constraints = self.__msgc_step12_low_resolution_segmentation()\n    seg = self.__msgc_step3_discontinuity_localization()\n    nlinks, unariesalt2, msinds = self.__msgc_step45678_hi2lo_construct_graph(hard_constraints, seg)\n    self.__msgc_step9_finish_perform_gc_and_reshape(nlinks, unariesalt2, msinds)"}
{"i": 3, "got": "def __ordered_values_by_indexes(self, data, inds):\n    \"\"\"pass\"\"\"\n    values = [None] * (np.max(inds) + 1)\n    linear_inds = inds.ravel()\n    linear_data = data.ravel()\n    for i in range(0, len(linear_inds)):\n        if values[linear_inds[i]] is None:\n            values[linear_inds[i]] = linear_data[i]\n        elif values[linear_inds[i]] < linear_data[i]:\n            values[linear_inds[i]] = linear_data[i]\n    values = np.asarray(values)\n    return values"}
{"i": 4, "got": "def __hi2lo_multiscale_indexes(self, mask, orig_shape):\n    \"\"\"pass\"\"\"\n    mask_orig = zoom_to_shape(mask, orig_shape, dtype=np.int8)\n    inds_small = np.arange(mask.size).reshape(mask.shape)\n    inds_small_in_orig = zoom_to_shape(inds_small, orig_shape, dtype=np.int8)\n    inds_orig = np.arange(np.prod(orig_shape)).reshape(orig_shape)\n    inds_orig += np.max(inds_small_in_orig) + 1\n    inds_small_in_orig[mask_orig == True] = inds_orig[np.max(inds_small_in_orig) + 1]\n    inds = inds_small_in_orig\n    inds = relabel_squeeze(inds)\n    logger.debug('Index after relabeling: %s', scipy.stats.describe(inds, axis=None))\n    return (inds, mask_orig)"}
{"i": 5, "got": "def interactivity(self, min_val=None, max_val=None, qt_app=None):\n    \"\"\"pass\"\"\"\n    from seed_editor_qt import QTSeedEditor\n    from PyQt4.QtGui import QApplication\n    if min_val is None:\n        min_val = np.min(self.img)\n    if max_val is None:\n        max_val = np.max(self.img)\n    window_c = (max_val + min_val) / 2\n    window_w = max_val - min_val\n    if qt_app is None:\n        qt_app = QApplication(sys.argv)\n    pyed = QTSeedEditor(modeFun=self.img, voxelSize=self.interactivity_loop, seeds=self.voxelsize, volume_unit=self.seeds, volume_unit=self.volume_unit)\n    pyed.changeC(window_c)\n    pyed.changeW(window_w)\n    qt_app.exec_()"}
{"i": 6, "got": "def expand(self, expression):\n    \"\"\"pass\"\"\"\n    self.logger.debug('expand : expression %s', str(expression))\n    if not is_string(expression):\n        return expression\n    result = self._pattern.sub(lambda var: str(self._variables[var.group(1)]), expression)\n    result = result.strip()\n    self.logger.debug('expand : %s - result : %s', expression, result)\n    if is_number(result):\n        if result.isdigit():\n            self.logger.debug('     expand is integer !!!')\n            return int(result)\n        else:\n            self.logger.debug('     expand is float !!!')\n            return float(result)\n    return result"}
{"i": 7, "got": "def get_gutter_client(alias='default', cache=CLIENT_CACHE, **kwargs):\n    \"\"\"pass\"\"\"\n    from gutter.client.models import Manager\n    if not alias:\n        return Manager(**kwargs)\n    elif alias not in cache:\n        cache[alias] = Manager(**kwargs)\n    return cache[alias]"}
{"i": 8, "got": "def _modulo(self, decimal_argument):\n    \"\"\"pass\"\"\"\n    _times, remainder = self._context.divmod(decimal_argument, 100)\n    if remainder >= 0:\n        return remainder\n    else:\n        return remainder + 100"}
{"i": 9, "got": "def enabled_for(self, inpt):\n    \"\"\"pass\"\"\"\n    signals.switch_checked.call(self)\n    signal_decorated = partial(self.__signal_and_return, inpt)\n    if self.state is self.states.GLOBAL:\n        return signal_decorated(True)\n    elif self.state is self.states.DISABLED:\n        return signal_decorated(False)\n    else:\n        conditions_dict = ConditionsDict.from_conditions_list(self.conditions)\n        conditions = conditions_dict.get_by_input(inpt)\n        if conditions:\n            result = self.__enabled_func((cond.call(inpt) for cond in conditions if cond.argument(inpt).applies))\n        else:\n            result = None\n        return signal_decorated(result)"}
{"i": 10, "got": "def call(self, inpt):\n    \"\"\"pass\"\"\"\n    if inpt is Manager.NONE_INPUT:\n        return False\n    argument_instance = self.argument(inpt)\n    if not argument_instance.applies:\n        return False\n    application = self.__apply(argument_instance, inpt)\n    if self.negative:\n        application = not application\n    return application"}
{"i": 11, "got": "def switches(self):\n    \"\"\"pass\"\"\"\n    results = [switch for name, switch in self.storage.iteritems() if name.startswith(self.__joined_namespace)]\n    return results"}
{"i": 12, "got": "def switch(self, name):\n    \"\"\"pass\"\"\"\n    try:\n        switch = self.storage[self.__namespaced(name)]\n    except KeyError:\n        if not self.autocreate:\n            raise ValueError(\"No switch named '%s' registered in '%s'\" % (name, self.namespace))\n        else:\n            switch = self.__create_and_register_disabled_switch(name)\n    switch.manager = self\n    return switch"}
{"i": 13, "got": "def when(obj, strict=None):\n    \"\"\"pass\"\"\"\n    if isinstance(obj, str):\n        obj = get_obj(obj)\n    if strict is None:\n        strict = True\n    theMock = _get_mock(obj, strict=strict)\n\n    class When(object):\n\n        def __getattr__(self, method_name):\n            return invocation.StubbedInvocation(theMock, method_name, strict=strict)\n    return When()"}
{"i": 14, "got": "def when2(fn, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    obj, name = get_obj_attr_tuple(fn)\n    theMock = _get_mock(obj, strict=True)\n    return invocation.StubbedInvocation(theMock, name)(*args, **kwargs)"}
{"i": 15, "got": "def patch(fn, attr_or_replacement, replacement=None):\n    \"\"\"pass\"\"\"\n    if replacement is None:\n        replacement = attr_or_replacement\n        return when2(fn, ...).thenAnswer(replacement)\n    else:\n        obj, name = (fn, attr_or_replacement)\n        theMock = _get_mock(obj, strict=True)\n        return invocation.StubbedInvocation(theMock, name, strict=False)(...).thenAnswer(replacement)"}
{"i": 16, "got": "def expect(obj, strict=None, times=None, atleast=None, atmost=None, between=None):\n    \"\"\"pass\"\"\"\n    if strict is None:\n        strict = True\n    theMock = _get_mock(obj, strict=strict)\n    verification_fn = _get_wanted_verification(times=times, atleast=atleast, atmost=atmost, between=between)\n\n    class Expect(object):\n\n        def __getattr__(self, method_name):\n            return invocation.StubbedInvocation(theMock, method_name, verification=verification_fn, strict=strict)\n    return Expect()"}
{"i": 17, "got": "def unstub(*objs):\n    \"\"\"pass\"\"\"\n    if objs:\n        for obj in objs:\n            mock_registry.unstub(obj)\n    else:\n        mock_registry.unstub_all()"}
{"i": 18, "got": "def verifyZeroInteractions(*objs):\n    \"\"\"pass\"\"\"\n    for obj in objs:\n        theMock = _get_mock_or_raise(obj)\n        if len(theMock.invocations) > 0:\n            raise VerificationError('\\nUnwanted interaction: %s' % theMock.invocations[0])"}
{"i": 19, "got": "def get_templates(model):\n    \"\"\"pass\"\"\"\n    for template_name, template in templates.items():\n        if issubclass(template.model, model):\n            yield (template_name, template.layout._meta.verbose_name)"}
{"i": 20, "got": "def attach(*layouts, **kwargs):\n    \"\"\"pass\"\"\"\n\n    def _model_admin_wrapper(layout_class):\n        register(layout_class, layouts[0])\n        return layout_class\n    return _model_admin_wrapper"}
{"i": 21, "got": "def get_api_envs():\n    \"\"\"pass\"\"\"\n    client_id = os.environ.get('CLIENT_ID')\n    user_id = os.environ.get('USER_ID')\n    if not (client_id and user_id):\n        raise ValueError('API keys are not found in the environment')\n    return (client_id, user_id)"}
{"i": 22, "got": "def api_call(method, end_point, params=None, client_id=None, access_token=None):\n    \"\"\"pass\"\"\"\n    if bool(client_id) == bool(access_token):\n        raise ValueError('Either client_id or access_token')\n    url = 'https://api.quizlet.com/2.0/{}'.format(end_point)\n    if not params:\n        params = {}\n    if client_id:\n        params['client_id'] = client_id\n    headers = {'Authorization': 'Bearer {}'.format(access_token)} if access_token else None\n    response = requests.request(method, url, params=params, headers=headers)\n    if int(response.status_code / 100) != 2:\n        error_title = ''\n        try:\n            error_title += ', ' + response.json()['error_title']\n        except ValueError:\n            pass\n        except KeyError:\n            pass\n        raise ValueError('{} returned {}{}'.format(url, response.status_code, error_title))\n    try:\n        return response.json()\n    except json.decoder.JSONDecodeError:\n        return None"}
{"i": 23, "got": "def exclusive(via=threading.Lock):\n    \"\"\"pass\"\"\"\n\n    def make_exclusive(fnc):\n        fnc_guard = via()\n\n        @functools.wraps(fnc)\n        def exclusive_call(*args, **kwargs):\n            if fnc_guard.acquire(blocking=False):\n                try:\n                    return fnc(*args, **kwargs)\n                finally:\n                    fnc_guard.release()\n            else:\n                raise RuntimeError('exclusive call to %s violated')\n        return exclusive_call\n    return make_exclusive"}
{"i": 24, "got": "def service(flavour):\n    \"\"\"pass\"\"\"\n\n    def service_unit_decorator(raw_cls):\n        __new__ = raw_cls.__new__\n\n        def __new_service__(cls, *args, **kwargs):\n            if __new__ is object.__new__:\n                self = __new__(cls)\n            else:\n                self = __new__(cls, *args, **kwargs)\n            service_unit = ServiceUnit(self, flavour)\n            self.__service_unit__ = service_unit\n            return self\n        raw_cls.__new__ = __new_service__\n        if raw_cls.run.__doc__ is None:\n            raw_cls.run.__doc__ = 'Service entry point'\n        return raw_cls\n    return service_unit_decorator"}
{"i": 25, "got": "def execute(self, payload: ModuleType, *args, flavour, **kwargs):\n    \"\"\"pass\"\"\"\n    if args or kwargs:\n        payload = functools.partial(payload, *args, **kwargs)\n    return self._meta_runner.run_payload(payload, flavour=flavour)"}
{"i": 26, "got": "def adopt(self, payload: ModuleType, *args, flavour, **kwargs):\n    \"\"\"pass\"\"\"\n    if args or kwargs:\n        payload = functools.partial(payload, *args, **kwargs)\n    self._meta_runner.register_payload(payload, flavour=flavour)"}
{"i": 27, "got": "def accept(self):\n    \"\"\"pass\"\"\"\n    if self._meta_runner:\n        raise RuntimeError('payloads scheduled for %s before being started' % self)\n    self._must_shutdown = False\n    self._logger.info('%s starting', self.__class__.__name__)\n    gc.collect()\n    self._adopt_services()\n    self.adopt(self._accept_services, flavour=trio)\n    self._meta_runner.run()"}
{"i": 28, "got": "def shutdown(self):\n    \"\"\"pass\"\"\"\n    self._must_shutdown = True\n    self._is_shutdown.wait()\n    self._meta_runner.stop()"}
{"i": 29, "got": "def milestones(ctx, list, close):\n    \"\"\"pass\"\"\"\n    repos = get_repos(ctx.parent.agile.get('labels'))\n    if list:\n        _list_milestones(repos)\n    elif close:\n        click.echo('Closing milestones \"%s\"' % close)\n        _close_milestone(repos, close)\n    else:\n        click.echo(ctx.get_help())"}
{"i": 30, "got": "def start_console(local_vars={}):\n    \"\"\"pass\"\"\"\n    transforms.CONSOLE_ACTIVE = True\n    transforms.remove_not_allowed_in_console()\n    sys.ps1 = prompt\n    console = ExperimentalInteractiveConsole(locals=local_vars)\n    console.interact(banner=banner)"}
{"i": 31, "got": "def push(self, line):\n    \"\"\"pass\"\"\"\n    if transforms.FROM_EXPERIMENTAL.match(line):\n        transforms.add_transformers(line)\n        self.buffer.append('\\n')\n    else:\n        self.buffer.append(line)\n    add_pass = False\n    if line.rstrip(' ').endswith(':'):\n        add_pass = True\n    source = '\\n'.join(self.buffer)\n    if add_pass:\n        source += 'pass'\n    source = transforms.transform(source)\n    if add_pass:\n        source = source.rstrip(' ')\n        if source.endswith('pass'):\n            source = source[:-4]\n    if not self.buffer[-1]:\n        source += '\\n'\n    try:\n        more = self.runsource(source, self.filename)\n    except SystemExit:\n        os._exit(1)\n    if not more:\n        self.resetbuffer()\n    return more"}
{"i": 32, "got": "def license_loader(lic_dir=LIC_DIR):\n    \"\"\"pass\"\"\"\n    lics = []\n    for ln in os.listdir(lic_dir):\n        lp = os.path.join(lic_dir, ln)\n        with open(lp) as lf:\n            txt = lf.read()\n            lic = License(txt)\n            lics.append(lic)\n    return lics"}
{"i": 33, "got": "def get_vector(self, max_choice=3):\n    \"\"\"pass\"\"\"\n    vec = {}\n    for dim in ['forbidden', 'required', 'permitted']:\n        if self.meta[dim] is not None:\n            dim_vec = map(lambda x: (x, max_choice), self.meta[dim])\n            vec[dim] = dict(dim_vec)\n    return vec"}
{"i": 34, "got": "def runcommand(cosmology='WMAP5'):\n    \"\"\"pass\"\"\"\n    Mi = [100000000.0, 1000000000.0, 10000000000.0]\n    zi = 0\n    print('Concentrations for haloes of mass %s at z=%s' % (Mi, zi))\n    output = commah.run(cosmology=cosmology, zi=zi, Mi=Mi)\n    print(output['c'].flatten())\n    Mi = [100000000.0, 1000000000.0, 10000000000.0]\n    zi = 0\n    print('Concentrations for haloes of mass %s at z=%s' % (Mi, zi))\n    output, cosmo = commah.run(cosmology=cosmology, zi=zi, Mi=Mi, retcosmo=True)\n    print(output['c'].flatten())\n    print(cosmo)\n    Mi = 2000000000000.0\n    z = [0, 0.5, 1, 1.5, 2, 2.5]\n    output = commah.run(cosmology=cosmology, zi=0, Mi=Mi, z=z)\n    for zval in z:\n        print('M(z=0)=%s has c(z=%s)=%s' % (Mi, zval, output[output['z'] == zval]['c'].flatten()))\n    Mi = 2000000000000.0\n    zi = [0, 0.5, 1, 1.5, 2, 2.5]\n    output = commah.run(cosmology=cosmology, zi=zi, Mi=Mi)\n    for zval in zi:\n        print('M(z=%s)=%s has concentration %s' % (zval, Mi, output[(output['zi'] == zval) & (output['z'] == zval)]['c'].flatten()))\n    Mi = 200000000000000.0\n    zi = 6\n    output = commah.run(cosmology=cosmology, zi=zi, Mi=Mi)\n    print('Concentrations for haloes of mass %s at z=%s' % (Mi, zi))\n    print(output['c'].flatten())\n    print('Mass variance sigma of haloes of mass %s at z=%s' % (Mi, zi))\n    print(output['sig'].flatten())\n    print('Fluctuation for haloes of mass %s at z=%s' % (Mi, zi))\n    print(output['nu'].flatten())\n    Mi = [100000000.0, 1000000000.0, 10000000000.0]\n    zi = [0]\n    z = [0, 0.5, 1, 1.5, 2, 2.5]\n    output = commah.run(cosmology=cosmology, zi=zi, Mi=Mi, z=z)\n    for Mval in Mi:\n        print('dM/dt for halo of mass %s at z=%s across redshift %s is: ' % (Mval, zi, z))\n        print(output[output['Mi'] == Mval]['dMdt'].flatten())\n    M = [100000000.0]\n    z = [0, 0.5, 1, 1.5, 2, 2.5]\n    print('Halo Mass History for z=0 mass of %s across z=%s' % (M, z))\n    output = commah.run(cosmology=cosmology, zi=0, Mi=M, z=z)\n    print(output['Mz'].flatten())\n    M = [100000000.0, 1000000000.0, 10000000000.0]\n    z = [0]\n    print('Formation Redshifts for haloes of mass %s at z=%s' % (M, z))\n    output = commah.run(cosmology=cosmology, zi=0, Mi=M, z=z)\n    for Mval in M:\n        print(output[output['Mi'] == Mval]['zf'].flatten())\n    return 'Done'"}
{"i": 35, "got": "def plotcommand(cosmology='WMAP5', plotname=None):\n    \"\"\"pass\"\"\"\n    xarray = 10 ** np.arange(1, 15, 0.2)\n    yval = 'c'\n    zarray = np.arange(0, 5, 0.5)\n    xtitle = 'Halo Mass (M$_{sol}$)'\n    ytitle = 'Concentration'\n    linelabel = 'z='\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.set_xlabel(xtitle)\n    ax.set_ylabel(ytitle)\n    plt.ylim([2, 30])\n    colors = cm.rainbow(np.linspace(0, 1, len(zarray)))\n    for zind, zval in enumerate(zarray):\n        output = commah.run(cosmology=cosmology, zi=zval, Mi=xarray)\n        yarray = output[yval].flatten()\n        ax.plot(xarray, yarray, label=linelabel + str(zval), color=colors[zind])\n        ax.plot(xarray, commah.commah.cduffy(zval, xarray), color='black')\n    ax.set_xscale('log')\n    ax.set_yscale('log')\n    leg = ax.legend(loc=1)\n    leg.get_frame().set_alpha(0)\n    leg.get_frame().set_edgecolor('white')\n    for label in leg.get_texts():\n        label.set_fontsize('small')\n    for label in leg.get_lines():\n        label.set_linewidth(4)\n    if plotname:\n        fig.tight_layout(pad=0.2)\n        print(\"Plotting to '%s_CM_relation.png'\" % plotname)\n        fig.savefig(plotname + '_CM_relation.png', dpi=fig.dpi * 5)\n    else:\n        plt.show()\n    xarray = 10 ** np.arange(0, 1, 0.05) - 1\n    yval = 'c'\n    zarray = 10 ** np.arange(6, 14, 2)\n    xtitle = 'Redshift'\n    ytitle = 'NFW Concentration'\n    linelabel = 'log$_{10}$ M$_{z}$(M$_{sol}$)='\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.set_xlabel(xtitle)\n    ax.set_ylabel(ytitle)\n    colors = cm.rainbow(np.linspace(0, 1, len(zarray)))\n    for zind, zval in enumerate(zarray):\n        output = commah.run(cosmology=cosmology, zi=zval, Mi=xarray)\n        yarray = output[yval].flatten()\n        ax.plot(xarray, yarray, label=linelabel + '{0:.1f}'.format(np.log10(zval)), color=colors[zind])\n    leg = ax.legend(loc=2)\n    leg.get_frame().set_alpha(0)\n    leg.get_frame().set_edgecolor('white')\n    for label in leg.get_texts():\n        label.set_fontsize('small')\n    for label in leg.get_lines():\n        label.set_linewidth(4)\n    if plotname:\n        fig.tight_layout(pad=0.2)\n        print(\"Plotting to '%s_Cz_relation.png'\" % plotname)\n        fig.savefig(plotname + '_Cz_relation.png', dpi=fig.dpi * 5)\n    else:\n        plt.show()\n    xarray = 10 ** np.arange(0, 1, 0.05) - 1\n    yval = 'zf'\n    zarray = 10 ** np.arange(6, 14, 2)\n    xtitle = 'Redshift'\n    ytitle = 'Formation Redshift'\n    linelabel = 'log$_{10}$ M$_{z}$(M$_{sol}$)='\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.set_xlabel(xtitle)\n    ax.set_ylabel(ytitle)\n    colors = cm.rainbow(np.linspace(0, 1, len(zarray)))\n    for zind, zval in enumerate(zarray):\n        output = commah.run(cosmology=cosmology, zi=zval, Mi=xarray)\n        yarray = output[yval].flatten()\n        ax.plot(xarray, yarray, label=linelabel + '{0:.1f}'.format(np.log10(zval)), color=colors[zind])\n    leg = ax.legend(loc=2)\n    leg.get_frame().set_alpha(0)\n    leg.get_frame().set_edgecolor('white')\n    for label in leg.get_texts():\n        label.set_fontsize('small')\n    for label in leg.get_lines():\n        label.set_linewidth(4)\n    if plotname:\n        fig.tight_layout(pad=0.2)\n        print(\"Plotting to '%s_zfz_relation.png'\" % plotname)\n        fig.savefig(plotname + '_zfz_relation.png', dpi=fig.dpi * 5)\n    else:\n        plt.show()\n    xarray = 10 ** np.arange(0, 1, 0.05) - 1\n    yval = 'dMdt'\n    zarray = 10 ** np.arange(10, 14, 0.5)\n    xtitle = 'log$_{10}$ (1+z)'\n    ytitle = 'log$_{10}$ Accretion Rate M$_{sol}$ yr$^{-1}$'\n    linelabel = 'log$_{10}$ M$_z$(M$_{sol}$)='\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.set_xlabel(xtitle)\n    ax.set_ylabel(ytitle)\n    colors = cm.rainbow(np.linspace(0, 1, len(zarray)))\n    cosmo = commah.getcosmo(cosmology)\n    for zind, zval in enumerate(zarray):\n        output = commah.run(cosmology=cosmology, zi=zval, Mi=xarray, com=False, mah=True)\n        yarray = output[yval].flatten()\n        ax.plot(np.log10(xarray + 1.0), np.log10(yarray) + linelabel + '{0:.1f}'.format(np.log10(zval)), color=colors[zind])\n        semianalytic_approx = 71.6 * (zval / 10 ** 9) * (cosmo['h'] / 0.7) * (-0.24 + 0.75 * (xarray + 1) * np.sqrt(cosmo['omega_M_0'] * (xarray + 1) ** 3 + cosmo['omega_lambda_0']))\n        ax.plot(np.log10(xarray + 1), np.log10(semianalytic_approx), color='black')\n    leg = ax.legend(loc=2)\n    leg.get_frame().set_alpha(0)\n    leg.get_frame().set_edgecolor('white')\n    for label in leg.get_texts():\n        label.set_fontsize('small')\n    for label in leg.get_lines():\n        label.set_linewidth(4)\n    if plotname:\n        fig.tight_layout(pad=0.2)\n        print(\"Plotting to '%s_dMdtz_relation.png'\" % plotname)\n        fig.savefig(plotname + '_dMdtz_relation.png', dpi=fig.dpi * 5)\n    else:\n        plt.show()\n    xarray = 10 ** np.arange(10, 14, 0.5)\n    yval = 'dMdt'\n    zarray = np.arange(0, 5, 0.5)\n    xtitle = 'Halo Mass M$_{sol}$'\n    ytitle = 'Accretion Rate M$_{sol}$ yr$^{-1}$'\n    linelabel = 'z='\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.set_xlabel(xtitle)\n    ax.set_ylabel(ytitle)\n    colors = cm.rainbow(np.linspace(0, 1, len(zarray)))\n    for zind, zval in enumerate(zarray):\n        output = commah.run(cosmology=cosmology, zi=zval, Mi=xarray)\n        yarray = output[yval].flatten()\n        ax.plot(xarray, yarray, label=linelabel + str(zval), color=colors[zind])\n    ax.set_xscale('log')\n    ax.set_yscale('log')\n    leg = ax.legend(loc=1)\n    leg.get_frame().set_alpha(0)\n    leg.get_frame().set_edgecolor('white')\n    for label in leg.get_texts():\n        label.set_fontsize('small')\n    for label in leg.get_lines():\n        label.set_linewidth(4)\n    if plotname:\n        fig.tight_layout(pad=0.2)\n        print(\"Plotting to '%s_MAH_M_relation.png'\" % plotname)\n        fig.savefig(plotname + '_MAH_M_relation.png', dpi=fig.dpi * 5)\n    else:\n        plt.show()\n    xarray = 10 ** np.arange(0, 1, 0.05) - 1\n    yval = 'dMdt'\n    zarray = 10 ** np.arange(10, 14, 0.5)\n    xtitle = 'Halo Mass M$_{sol}$'\n    ytitle = 'Specific Accretion Rate yr$^{-1}$'\n    lin"}
{"i": 36, "got": "def add_transformers(line):\n    \"\"\"pass\"\"\"\n    assert FROM_EXPERIMENTAL.match(line)\n    line = FROM_EXPERIMENTAL.sub(' ', line)\n    line = line.split('#')[0]\n    for trans in line.replace(' ', '').split(','):\n        import_transformer(trans)"}
{"i": 37, "got": "def import_transformer(name):\n    \"\"\"pass\"\"\"\n    if name in transformers:\n        return transformers[name]\n    hook = sys.meta_path[0]\n    sys.meta_path = sys.meta_path[1:]\n    try:\n        transformers[name] = __import__(name)\n        if CONSOLE_ACTIVE and hasattr(transformers[name], 'NO_CONSOLE'):\n            print(transformers[name].NO_CONSOLE)\n            transformers[name] = NullTransformer()\n    except ImportError:\n        sys.stderr.write('Warning: Import Error in add_transformers: %s not found\\n' % name)\n        transformers[name] = NullTransformer()\n    except Exception as e:\n        sys.stderr.write('Unexpected exception in transforms.import_transformer%s\\n ' % e.__class__.__name__)\n    finally:\n        sys.meta_path.insert(0, hook)\n    return transformers[name]"}
{"i": 38, "got": "def extract_transformers_from_source(source):\n    \"\"\"pass\"\"\"\n    lines = source.split('\\n')\n    linenumbers = []\n    for number, line in enumerate(lines):\n        if FROM_EXPERIMENTAL.match(line):\n            add_transformers(line)\n            linenumbers.insert(0, number)\n    for number in linenumbers:\n        del lines[number]\n    return '\\n'.join(lines)"}
{"i": 39, "got": "def remove_not_allowed_in_console():\n    \"\"\"pass\"\"\"\n    not_allowed_in_console = []\n    if CONSOLE_ACTIVE:\n        for name in transformers:\n            tr_module = import_transformer(name)\n            if hasattr(tr_module, 'NO_CONSOLE'):\n                not_allowed_in_console.append((name, tr_module))\n        for name, tr_module in not_allowed_in_console:\n            print(tr_module.NO_CONSOLE)\n            transformers[name] = NullTransformer()"}
{"i": 40, "got": "def _match(self, request, response):\n    \"\"\"pass\"\"\"\n    is_html = 'text/html' in response.get('Content-Type', '')\n    if is_html and hasattr(response, 'rendered_content'):\n        correct_path = PATH_MATCHER.match(request.path) is not None\n        not_included = self.include_flag not in response.rendered_content\n        return correct_path and not_included\n    else:\n        return False"}
{"i": 41, "got": "def _chosen_css(self):\n    \"\"\"pass\"\"\"\n    css = render_to_string(self.css_template, {})\n    for sprite in self.chosen_sprites:\n        css = css.replace(sprite, settings.STATIC_URL + 'img/' + sprite)\n    return css"}
{"i": 42, "got": "def _embed(self, request, response):\n    \"\"\"pass\"\"\"\n    if self._match(request, response):\n        head = render_to_string('chosenadmin/_head_css.html', {'chosen_css': self._chosen_css()})\n        body = render_to_string('chosenadmin/_script.html', {'chosen_js': self._chosen_js()})\n        content = response.rendered_content\n        content = content.replace('</head>', head)\n        content = content.replace('</body>', body)\n        response.content = content\n    return response"}
{"i": 43, "got": "def clean_up(self):\n    \"\"\"pass\"\"\"\n    self.log.debug('Closing I2C bus for address: 0x%02X' % self.address)\n    self.bus.close()"}
{"i": 44, "got": "def write_quick(self):\n    \"\"\"pass\"\"\"\n    self.bus.write_quick(self.address)\n    self.log.debug('write_quick: Sent the read / write bit')"}
{"i": 45, "got": "def write_byte(self, cmd, value):\n    \"\"\"pass\"\"\"\n    self.bus.write_byte_data(self.address, cmd, value)\n    self.log.debug('write_byte: Wrote 0x%02X to command register 0x%02X' % (value, cmd))"}
{"i": 46, "got": "def write_word(self, cmd, value):\n    \"\"\"pass\"\"\"\n    self.bus.write_word_data(self.address, cmd, value)\n    self.log.debug('write_word: Wrote 0x%04X to command register 0x%02X' % (value, cmd))"}
{"i": 47, "got": "def write_raw_byte(self, value):\n    \"\"\"pass\"\"\"\n    self.bus.write_byte(self.address, value)\n    self.log.debug('write_raw_byte: Wrote 0x%02X' % value)"}
{"i": 48, "got": "def write_block_data(self, cmd, block):\n    \"\"\"pass\"\"\"\n    self.bus.write_i2c_block_data(self.address, cmd, block)\n    self.log.debug('write_block_data: Wrote [%s] to command register 0x%02X' % (', '.join(['0x%02X' % x for x in block]), cmd))"}
{"i": 49, "got": "def get_formset(self, request, obj=None, **kwargs):\n    \"\"\"pass\"\"\"\n    data = super().get_formset(request, obj, **kwargs)\n    if obj:\n        data.form.base_fields['user'].initial = request.user.id\n    return data"}
{"i": 50, "got": "def process_actions(action_ids=None):\n    \"\"\"pass\"\"\"\n    actions_taken = 0\n    action_list = PublishAction.objects.prefetch_related('content_object').filter(scheduled_time__lte=timezone.now())\n    if action_ids is not None:\n        action_list = action_list.filter(id__in=action_ids)\n    for action in action_list:\n        action.process_action()\n        action.delete()\n        actions_taken += 1\n    return actions_taken"}
{"i": 51, "got": "def celery_enabled():\n    \"\"\"pass\"\"\"\n    enabled = getattr(settings, 'GLITTER_PUBLISHER_CELERY', None)\n    if enabled is None:\n        try:\n            import celery\n            enabled = True\n        except ImportError:\n            enabled = False\n    return enabled"}
{"i": 52, "got": "def do_command_line(infile: typing.IO[str]) -> int:\n    \"\"\"pass\"\"\"\n    lines = infile.readlines()\n    tree = ast.parse(''.join(lines))\n    checker = Checker(tree, lines, infile.name)\n    checker.load()\n    errors = []\n    for func in checker.all_funcs(skip_noqa=True):\n        try:\n            errors = list(func.check_all())\n        except ValidationError as error:\n            errors = [error.to_aaa()]\n        print(func.__str__(errors), end='')\n    return len(errors)"}
{"i": 53, "got": "def _izip(*iterables):\n    \"\"\"pass\"\"\"\n    iterators = map(iter, iterables)\n    while iterators:\n        yield tuple(map(next, iterators))"}
{"i": 54, "got": "def _checkinput(zi, Mi, z, verbose=False):\n    \"\"\"pass\"\"\"\n    zi = np.array(zi, ndmin=1, dtype=float)\n    Mi = np.array(Mi, ndmin=1, dtype=float)\n    if zi.size > 1 and Mi.size > 1:\n        if zi.size != Mi.size:\n            print('Error ambiguous request')\n            print('Need individual redshifts for all haloes provided ')\n            print('Or have all haloes at same redshift ')\n            return -1\n    elif zi.size == 1 and Mi.size > 1:\n        if verbose:\n            print('Assume zi is the same for all Mi halo masses provided')\n        zi = np.ones_like(Mi) * zi[0]\n    elif Mi.size == 1 and zi.size > 1:\n        if verbose:\n            print('Assume Mi halo masses are the same for all zi provided')\n        Mi = np.ones_like(zi) * Mi[0]\n    else:\n        if verbose:\n            print('A single Mi and zi provided')\n    if z is False:\n        lenzout = 1\n    else:\n        z = np.array(z, ndmin=1, dtype=float)\n        lenzout = z.size\n    return (zi, Mi, z, zi.size, Mi.size, lenzout)"}
{"i": 55, "got": "def getcosmo(cosmology):\n    \"\"\"pass\"\"\"\n    defaultcosmologies = {'dragons': cg.DRAGONS(), 'wmap1': cg.WMAP1_Mill(), 'wmap3': cg.WMAP3_ML(), 'wmap5': cg.WMAP5_mean(), 'wmap7': cg.WMAP7_ML(), 'wmap9': cg.WMAP9_ML(), 'wmap1_lss': cg.WMAP1_2dF_mean(), 'wmap3_mean': cg.WMAP3_mean(), 'wmap5_ml': cg.WMAP5_ML(), 'wmap5_lss': cg.WMAP5_BAO_SN_mean(), 'wmap7_lss': cg.WMAP7_BAO_H0_mean(), 'planck13': cg.Planck_2013(), 'planck15': cg.Planck_2015()}\n    if isinstance(cosmology, dict):\n        cosmo = cosmology\n        if 'A_scaling' not in cosmology.keys():\n            A_scaling = getAscaling(cosmology, newcosmo=True)\n            cosmo.update({'A_scaling': A_scaling})\n        for paramnames in cg.WMAP5_mean().keys():\n            if paramnames not in cosmology.keys():\n                cosmo.update({paramnames: 0})\n    elif cosmology.lower() in defaultcosmologies.keys():\n        cosmo = defaultcosmologies[cosmology.lower()]\n        A_scaling = getAscaling(cosmology)\n        cosmo.update({'A_scaling': A_scaling})\n    else:\n        print(\"You haven't passed a dict of cosmological parameters \")\n        print('OR a recognised cosmology, you gave %s' % cosmology)\n    cosmo = cp.distance.set_omega_k_0(cosmo)\n    return cosmo"}
{"i": 56, "got": "def _getcosmoheader(cosmo):\n    \"\"\"pass\"\"\"\n    cosmoheader = '# Cosmology (flat) Om:{0:.3f}, Ol:{1:.3f}, h:{2:.2f}, sigma8:{3:.3f}, ns:{4:.2f}'.format(cosmo['omega_M_0'], cosmo['omega_lambda_0'], cosmo['h'], cosmo['sigma_8'], cosmo['n'])\n    return cosmoheader"}
{"i": 57, "got": "def tag(self, tag):\n    \"\"\"pass\"\"\"\n    url = '%s/tags/%s' % (self, tag)\n    response = self.http.get(url, auth=self.auth)\n    response.raise_for_status()\n    return response.json()"}
{"i": 58, "got": "def release_assets(self, release):\n    \"\"\"pass\"\"\"\n    release = self.as_id(release)\n    return self.get_list(url='%s/%s/assets' % (self, release))"}
{"i": 59, "got": "def upload(self, release, filename, content_type=None):\n    \"\"\"pass\"\"\"\n    release = self.as_id(release)\n    name = os.path.basename(filename)\n    if not content_type:\n        content_type, _ = mimetypes.guess_type(name)\n    if not content_type:\n        raise ValueError('content_type not known')\n    inputs = {'name': name}\n    url = '%s%s/%s/assets' % (self.uploads_url, urlsplit(self.api_url).path, release)\n    info = os.stat(filename)\n    size = info[stat.ST_SIZE]\n    response = self.http.post(url, data=stream_upload(filename), auth=self.auth, params=inputs, headers={'content-type': content_type, 'content-length': str(size)})\n    response.raise_for_status()\n    return response.json()"}
{"i": 60, "got": "def validate_tag(self, tag_name, prefix=None):\n    \"\"\"pass\"\"\"\n    new_version = semantic_version(tag_name)\n    current = self.latest()\n    if current:\n        tag_name = current['tag_name']\n        if prefix:\n            tag_name = tag_name[len(prefix):]\n        tag_name = semantic_version(tag_name)\n        if tag_name >= new_version:\n            what = 'equal to' if tag_name == new_version else 'older than'\n            raise GithubException('Your local version \"%s\" is %s the current github version \"%s\".\\nBump the local version to continue.' % (str(new_version), what, str(tag_name)))\n    return current"}
{"i": 61, "got": "def is_related_to(item, app_id, app_ver=None):\n    \"\"\"pass\"\"\"\n    versionRange = item.get('versionRange')\n    if not versionRange:\n        return True\n    for vR in versionRange:\n        if not vR.get('targetApplication'):\n            return True\n        if get_related_targetApplication(vR, app_id, app_ver) is not None:\n            return True\n    return False"}
{"i": 62, "got": "def get_related_targetApplication(vR, app_id, app_ver):\n    \"\"\"pass\"\"\"\n    targetApplication = vR.get('targetApplication')\n    if not targetApplication:\n        return None\n    for tA in targetApplication:\n        guid = tA.get('guid')\n        if not guid or guid == app_id:\n            continue\n        if not app_ver:\n            return tA\n        if between(version_int(app_ver), '0', tA.get('maxVersion', '*')):\n            return tA"}
{"i": 63, "got": "def write_addons_items(xml_tree, records, app_id, api_ver=3, app_ver=None):\n    \"\"\"pass\"\"\"\n    if not records:\n        return\n    emItems = etree.SubElement(xml_tree, 'emItems')\n    groupby = {}\n    for item in records:\n        if is_related_to(item, app_id, app_ver):\n            if item['guid'] in groupby:\n                emItem = groupby[item['guid']]\n                if 'blockID' in item:\n                    current_blockID = int(item['blockID'][1:])\n                    previous_blockID = int(emItem.attrib['blockID'][1:])\n                    if current_blockID > previous_blockID:\n                        emItem.attrib['blockID'] = item['blockID']\n                else:\n                    emItem.attrib['blockID'] = item['id']\n            else:\n                emItem = etree.SubElement(emItems, 'emItem', blockID=item.get('blockID', item['id']))\n                groupby[item['guid']] = emItem\n                prefs = etree.SubElement(emItem, 'prefs')\n                for p in item['prefs']:\n                    pref = etree.SubElement(prefs, 'pref')\n                    pref.text = p\n            emItem.set('id', item['guid'])\n            for field in ['name', 'os']:\n                if field in item:\n                    emItem.set(field, item[field])\n            build_version_range(emItem, item, app_id)"}
{"i": 64, "got": "def write_plugin_items(xml_tree, records, app_id, api_ver=3, app_ver=None):\n    \"\"\"pass\"\"\"\n    if not records:\n        return\n    pluginItems = etree.SubElement(xml_tree, 'pluginItems')\n    for item in records:\n        for versionRange in item.get('versionRange', []):\n            if not versionRange.get('targetApplication'):\n                add_plugin_item(pluginItems, item, versionRange, app_id=app_id, api_ver=api_ver, app_ver=app_ver)\n            else:\n                targetApplication = get_related_targetApplication(versionRange, app_id, app_ver)\n                if targetApplication is not None:\n                    add_plugin_item(pluginItems, item, versionRange, targetApplication, app_id=app_id, api_ver=api_ver, app_ver=app_ver)"}
{"i": 65, "got": "def write_gfx_items(xml_tree, records, app_id, api_ver=3):\n    \"\"\"pass\"\"\"\n    if not records:\n        return\n    gfxItems = etree.SubElement(xml_tree, 'gfxItems')\n    for item in records:\n        is_record_related = 'guid' not in item or item['guid'] == app_id\n        if not is_record_related:\n            continue\n        entry = etree.SubElement(gfxItems, 'gfxBlacklistEntry', blockID=item.get('blockID', item['id']))\n        fields = ['os', 'vendor', 'feature', 'featureStatus', 'driverVersion', 'driverVersionComparator']\n        for field in fields:\n            if field in item:\n                node = etree.SubElement(entry, field)\n                node.text = item[field]\n        if item['devices']:\n            devices = etree.SubElement(entry, 'devices')\n            for d in item['devices']:\n                device = etree.SubElement(devices, 'device')\n                device.text = d\n        if 'versionRange' in item:\n            version = item['versionRange']\n            versionRange = etree.SubElement(entry, 'versionRange')\n            for field in ['minVersion', 'maxVersion']:\n                value = version.get(field)\n                if value:\n                    versionRange.set(field, str(value))"}
{"i": 66, "got": "def write_cert_items(xml_tree, records, api_ver=3, app_id=None, app_ver=None):\n    \"\"\"pass\"\"\"\n    if not records or not should_include_certs(app_id, app_ver):\n        return\n    certItems = etree.SubElement(xml_tree, 'certItems')\n    for item in records:\n        if item.get('subject') and item.get('pubKeyHash'):\n            cert = etree.SubElement(certItems, 'certItem', subject=item['subject'], pubKeyHash=item['pubKeyHash'])\n        else:\n            cert = etree.SubElement(certItems, 'certItem', issuerName=item['issuerName'])\n            serialNumber = etree.SubElement(cert, 'serialNumber')\n            serialNumber.text = item['serialNumber']"}
{"i": 67, "got": "def label(self, name, color, update=True):\n    \"\"\"pass\"\"\"\n    url = '%s/labels' % self\n    data = dict(name=name, color=color)\n    response = self.http.post(url, json=data, auth=self.auth, headers=self.headers)\n    if response.status_code == 201:\n        return True\n    elif response.status_code == 422 and update:\n        url = '%s/%s' % (url, name)\n        response = self.http.patch(url, json=data, auth=self.auth, headers=self.headers)\n    response.raise_for_status()\n    return False"}
{"i": 68, "got": "def get_interval_timedelta(self):\n    \"\"\"pass\"\"\"\n    now_datetime = timezone.now()\n    current_month_days = monthrange(now_datetime.year, now_datetime.month)[1]\n    if self.interval == reminders_choices.INTERVAL_2_WEEKS:\n        interval_timedelta = datetime.timedelta(days=14)\n    elif self.interval == reminders_choices.INTERVAL_ONE_MONTH:\n        interval_timedelta = datetime.timedelta(days=current_month_days)\n    elif self.interval == reminders_choices.INTERVAL_THREE_MONTHS:\n        three_months = now_datetime + relativedelta(months=3)\n        interval_timedelta = three_months - now_datetime\n    elif self.interval == reminders_choices.INTERVAL_SIX_MONTHS:\n        six_months = now_datetime + relativedelta(months=6)\n        interval_timedelta = six_months - now_datetime\n    elif self.interval == reminders_choices.INTERVAL_ONE_YEAR:\n        one_year = now_datetime + relativedelta(years=1)\n        interval_timedelta = one_year - now_datetime\n    return interval_timedelta"}
{"i": 69, "got": "def _build_mappings(self, classes: Sequence[type]) -> Tuple[Mapping[type, Sequence[type]], Mapping[type, Sequence[type]]]:\n    \"\"\"pass\"\"\"\n    parents_to_children = {}\n    children_to_parents = {}\n    visited_classes = set()\n    class_stack = list(classes)\n    while class_stack:\n        class_ = class_stack.pop()\n        if class_ in visited_classes:\n            continue\n        visited_classes.add(class_)\n        for base in class_.__bases__:\n            if base not in visited_classes:\n                class_stack.append(base)\n            parents_to_children.setdefault(base, set()).add(class_)\n            children_to_parents.setdefault(class_, set()).add(base)\n    sorted_parents_to_children = collections.OrderedDict()\n    for parent, children in sorted(parents_to_children.items(), key=lambda x: (x[0].__module__, x[0].__name__)):\n        sorted_parents_to_children[parent] = sorted(children, key=lambda x: (x.__module__, x.__name__))\n    sorted_children_to_parents = collections.OrderedDict()\n    for child, parents in sorted(children_to_parents.items(), key=lambda x: (x[0].__module__, x[0].__name__)):\n        sorted_children_to_parents[child] = sorted(parents, key=lambda x: (x.__module__, x.__name__))\n    return (sorted_parents_to_children, sorted_children_to_parents)"}
{"i": 70, "got": "def _collect_classes(self, package_paths: Sequence[str], recurse_subpackages=True) -> Sequence[type]:\n    \"\"\"pass\"\"\"\n    import uqbar.apis\n    classes = []\n    initial_source_paths = set()\n    for path in package_paths:\n        try:\n            module = importlib.import_module(path)\n            if hasattr(module, '__path__'):\n                initial_source_paths.update(getattr(module, '__path__'))\n            else:\n                initial_source_paths.add(module.__file__)\n        except ModuleNotFoundError:\n            path, _, class_name = path.rpartition('.')\n            module = importlib.import_module(path)\n            classes.append(getattr(module, class_name))\n    for source_path in uqbar.apis.collect_source_paths(initial_source_paths, recurse_subpackages=recurse_subpackages):\n        package_path = uqbar.apis.source_path_to_package_path(source_path)\n        module = importlib.import_module(package_path)\n        for name in dir(module):\n            if not name.startswith('_'):\n                object_ = getattr(module, name)\n                if isinstance(object_, type) and object_.__module__ == module.__name__:\n                    classes.append(object_)\n    return sorted(classes, key=lambda x: (x.__module__, x.__name__))"}
{"i": 71, "got": "def find_common_prefix(paths: Sequence[Union[str, pathlib.Path]]) -> Optional[pathlib.Path]:\n    \"\"\"pass\"\"\"\n    counter = collections.Counter()\n    for path in paths:\n        path = pathlib.Path(path)\n        counter.update([path])\n        counter.update(path.parents)\n    valid_paths = sorted([path for path, count in counter.items() if count >= len(paths)], key=lambda x: len(x.parts))\n    if valid_paths:\n        return valid_paths[-1]\n    else:\n        return None"}
{"i": 72, "got": "def find_executable(name: str, flags=os.X_OK) -> List[str]:\n    \"\"\"pass\"\"\"\n    result = []\n    extensions = [x for x in os.environ.get('PATHEXT', '').split(os.pathsep) if x]\n    path = os.environ.get('PATH', None)\n    if path is None:\n        return []\n    for path in os.environ.get('PATH', '').split(os.pathsep):\n        path = os.path.join(path, name)\n        if os.access(path, flags):\n            result.append(path)\n        for extension in extensions:\n            path_extension = path + extension\n            if os.access(path_extension, flags):\n                result.append(path_extension)\n    return result"}
{"i": 73, "got": "def relative_to(source_path: Union[str, pathlib.Path], target_path: Union[str, pathlib.Path]) -> pathlib.Path:\n    \"\"\"pass\"\"\"\n    source_path = pathlib.Path(source_path).absolute()\n    if source_path.is_file():\n        source_path = source_path.parent\n    target_path = pathlib.Path(target_path).absolute()\n    common_prefix = find_common_prefix([source_path, target_path])\n    if not common_prefix:\n        raise ValueError('No common prefix')\n    source_path = source_path.relative_to(common_prefix)\n    target_path = target_path.relative_to(common_prefix)\n    result = pathlib.Path(['..'] * len(source_path.parts))\n    return result / target_path"}
{"i": 74, "got": "def walk(root_path: Union[str, pathlib.Path], top_down: bool=True) -> Generator[Tuple[pathlib.Path, Sequence[pathlib.Path], Sequence[pathlib.Path]], None, None]:\n    \"\"\"pass\"\"\"\n    root_path = pathlib.Path(root_path)\n    directory_paths, file_paths = ([], [])\n    for path in sorted(root_path.iterdir()):\n        if path.is_dir():\n            directory_paths.append(path)\n        else:\n            file_paths.append(path)\n    if top_down:\n        yield (root_path, directory_paths, file_paths)\n    for directory_path in directory_paths:\n        yield from walk(directory_path, top_down=top_down)\n    if not top_down:\n        yield (root_path, directory_paths, file_paths)"}
{"i": 75, "got": "def run(self) -> Generator[Tuple[int, int, str, type], None, None]:\n    \"\"\"pass\"\"\"\n    if is_test_file(self.filename):\n        self.load()\n        for func in self.all_funcs():\n            try:\n                for error in func.check_all():\n                    yield (error.line_number, error.offset, error.text, Checker)\n            except ValidationError as error:\n                yield error.to_flake8(Checker)"}
{"i": 76, "got": "def make_driver(loop=None):\n    \"\"\"pass\"\"\"\n    loop = loop or asyncio.get_event_loop()\n\n    def stop(i=None):\n        loop.stop()\n\n    def driver(sink):\n        \"\"\"pass\"\"\"\n        sink.control.subscribe(on_next=stop, on_error=stop, on_completed=stop)\n    return Component(call=driver, input=Sink)"}
{"i": 77, "got": "def _stdin_(p):\n    \"\"\"pass\"\"\"\n    _v = sys.version[0]\n    if _v is '3':\n        return input(p)\n    else:\n        return raw_input(p)"}
{"i": 78, "got": "def survey_loader(sur_dir=SUR_DIR, sur_file=SUR_FILE):\n    \"\"\"pass\"\"\"\n    survey_path = os.path.join(sur_dir, sur_file)\n    survey = None\n    with open(survey_path) as survey_file:\n        survey = Survey(survey_file.read())\n    return survey"}
{"i": 79, "got": "def format_choices(self):\n    \"\"\"pass\"\"\"\n    ce = enumerate(self.choices)\n    f = lambda i, c: '%s (%d)' % (c, i + 1)\n    toks = [f(i, c) for i, c in ce] + ['Help (?)']\n    return ' '.join(toks)"}
{"i": 80, "got": "def is_answer_valid(self, ans):\n    \"\"\"pass\"\"\"\n    return ans in [str(i + 1) for i in range(len(self.choices))]"}
{"i": 81, "got": "def update(self, span: typing.Tuple[int, int], line_type: LineType) -> None:\n    \"\"\"pass\"\"\"\n    first_block_line, last_block_line = span\n    for i in range(first_block_line, last_block_line + 1):\n        try:\n            self.__setitem__(i, line_type)\n        except ValueError as error:\n            raise ValidationError(i + self.fn_offset, 1, 'AAA99 {}'.format(error))"}
{"i": 82, "got": "def check_arrange_act_spacing(self) -> typing.Generator[AAAError, None, None]:\n    \"\"\"pass\"\"\"\n    yield from self.check_block_spacing(LineType.arrange, LineType.act, 'AAA03 expected 1 blank line before Act block, found {}')"}
{"i": 83, "got": "def check_act_assert_spacing(self) -> typing.Generator[AAAError, None, None]:\n    \"\"\"pass\"\"\"\n    yield from self.check_block_spacing(LineType.act, LineType._assert, 'AAA04 expected 1 blank line before Assert block, found {}')"}
{"i": 84, "got": "def check_block_spacing(self, first_block_type: LineType, second_block_type: LineType, error_message: str) -> typing.Generator[AAAError, None, None]:\n    \"\"\"pass\"\"\"\n    numbered_lines = list(enumerate(self))\n    first_block_lines = filter(lambda l: l[1] is first_block_type, numbered_lines)\n    try:\n        first_block_lineno = list(first_block_lines)[-1][0]\n    except IndexError:\n        return\n    second_block_lines = filter(lambda l: l[1] is second_block_type, numbered_lines)\n    try:\n        second_block_lineno = next(second_block_lines)[0]\n    except StopIteration:\n        return\n    blank_lines = [bl for bl in numbered_lines[first_block_lineno + 1:second_block_lineno] if bl[1] is LineType.blank_line]\n    if not blank_lines:\n        yield AAAError(line_number=self.fn_offset + second_block_lineno - 1, offset=0, text=error_message.format('none'))\n    elif len(blank_lines) > 1:\n        yield AAAError(line_number=self.fn_offset + blank_lines[1][0], offset=0, text=error_message.format(len(blank_lines)))"}
{"i": 85, "got": "def get_access_token(self, code):\n    \"\"\"pass\"\"\"\n    try:\n        self._token = super().fetch_token(MINUT_TOKEN_URL, client_id=self._client_id, client_secret=self._client_secret, code=code)\n    except MissingTokenError as error:\n        _LOGGER.debug('Token issues: %s', error)\n    return self._token"}
{"i": 86, "got": "def _request(self, url, request_type='GET', **params):\n    \"\"\"pass\"\"\"\n    try:\n        _LOGGER.debug('Request %s %s', url, params)\n        response = self.request(request_type, url, timeout=TIMEOUT.seconds, **params)\n        response.raise_for_status()\n        _LOGGER.debug('Response %s %s %.200s', response.status_code, response.headers['content-type'], response.json())\n        response = response.json()\n        if 'error' in response:\n            raise OSError(response['error'])\n        return response\n    except OSError as error:\n        _LOGGER.warning('Failed request: %s', error)\n        return None"}
{"i": 87, "got": "def _request_devices(self, url, _type):\n    \"\"\"pass\"\"\"\n    res = self._request(url)\n    return res.get(_type) if res else {}"}
{"i": 88, "got": "def read_sensor(self, device_id, sensor_uri):\n    \"\"\"pass\"\"\"\n    url = MINUT_DEVICES_URL + '/{device_id}/{sensor_uri}'.format(device_id=device_id, sensor_uri=sensor_uri)\n    res = self._request(url, request_type='GET', data={'limit': 1})\n    if not res.get('values'):\n        return None\n    return res.get('values')[-1].get('value')"}
{"i": 89, "got": "def _register_webhook(self, webhook_url, events):\n    \"\"\"pass\"\"\"\n    response = self._request(MINUT_WEBHOOKS_URL, request_type='POST', json={'url': webhook_url, 'events': events})\n    return response"}
{"i": 90, "got": "def remove_webhook(self):\n    \"\"\"pass\"\"\"\n    if self._webhook.get('hook_id'):\n        self._request('{}/{}'.format(MINUT_WEBHOOKS_URL, self._webhook['hook_id']), request_type='DELETE')"}
{"i": 91, "got": "def _get_ip():\n    \"\"\"pass\"\"\"\n    cmd_netstat = ['netstat', '-nr']\n    p1 = subprocess.Popen(cmd_netstat, stdout=subprocess.PIPE)\n    cmd_grep = ['grep', '^0\\\\.0\\\\.0\\\\.0']\n    p2 = subprocess.Popen(cmd_grep, stdin=p1.stdout, stdout=subprocess.PIPE)\n    cmd_awk = ['awk', '{ print $2 }']\n    p3 = subprocess.Popen(cmd_awk, stdin=p2.stdout, stdout=subprocess.PIPE)\n    galaxy_ip = p3.stdout.read()\n    log.debug('Host IP determined to be %s', galaxy_ip)\n    return galaxy_ip"}
{"i": 92, "got": "def get_galaxy_connection(history_id=None, obj=True):\n    \"\"\"pass\"\"\"\n    history_id = history_id or os.environ['HISTORY_ID']\n    key = os.environ['API_KEY']\n    galaxy_ip = _get_ip()\n    url = Template(os.environ['GALAXY_URL']).safe_substitute({'DOCKER_HOST': galaxy_ip})\n    gi = _test_url(url, key, history_id, obj=obj)\n    if gi is not None:\n        return gi\n    app_path = os.environ['GALAXY_URL'].rstrip('/')\n    app_path = ''.join(app_path.split('/')[3:])\n    if 'GALAXY_WEB_PORT' not in os.environ:\n        raise Exception('No port')\n    galaxy_port = os.environ['GALAXY_WEB_PORT']\n    built_galaxy_url = 'http://%s:%s/%s' % (galaxy_ip.strip(), galaxy_port, app_path.strip())\n    url = built_galaxy_url.rstrip('/')\n    gi = _test_url(url, key, history_id, obj=obj)\n    if gi is not None:\n        return gi\n    msg = 'Could not connect to a galaxy instance. Please contact your SysAdmin for help with this error'\n    raise Exception(msg)"}
{"i": 93, "got": "def put(filenames, file_type='auto', history_id=None):\n    \"\"\"pass\"\"\"\n    history_id = history_id or os.environ['HISTORY_ID']\n    gi = get_galaxy_connection(history_id=history_id)\n    for filename in filenames:\n        log.debug('Uploading gx=%s history=%s localpath=%s ft=%s', gi, history_id, filename, file_type)\n        history = gi.histories.get(history_id)\n        history.upload_dataset(filename, file_type=file_type)"}
{"i": 94, "got": "def get(datasets_identifiers, identifier_type='hid', history_id=None):\n    \"\"\"pass\"\"\"\n    history_id = history_id or os.environ['HISTORY_ID']\n    gi = get_galaxy_connection(history_id=history_id, obj=False)\n    for dataset_identifier in datasets_identifiers:\n        file_path = '/import/%s' % dataset_identifier\n        log.debug('Downloading gx=%s history=%s dataset=%s', gi, history_id, dataset_identifier)\n        if not os.path.exists(file_path):\n            hc = HistoryClient(gi)\n            dc = DatasetClient(gi)\n            history = hc.show_history(history_id, contents=True)\n            datasets = {ds[identifier_type]: ds['id'] for ds in history}\n            if identifier_type == 'hid':\n                dataset_identifier = int(dataset_identifier)\n            dc.download_dataset(datasets[dataset_identifier], file_path=file_path, use_default_filename=False)\n        else:\n            log.debug('Cached, not re-downloading')\n    return file_path"}
{"i": 95, "got": "def get_user_history(history_id=None):\n    \"\"\"pass\"\"\"\n    history_id = history_id or os.environ['HISTORY_ID']\n    gi = get_galaxy_connection(history_id=history_id, obj=False)\n    hc = HistoryClient(gi)\n    history = hc.show_history(history_id, visible=True, contents=True)\n    return history"}
{"i": 96, "got": "def get_user_sets(client_id, user_id):\n    \"\"\"pass\"\"\"\n    data = api_call('get', 'users/{}/sets'.format(user_id), client_id=client_id)\n    return [WordSet.from_dict(wordset) for wordset in data]"}
{"i": 97, "got": "def print_user_sets(wordsets, print_terms):\n    \"\"\"pass\"\"\"\n    if not wordsets:\n        print('No sets found')\n        return\n    print('Found sets: {}'.format(len(wordsets)))\n    for wordset in wordsets:\n        print('    {}'.format(wordset))\n        if print_terms:\n            for term in wordset.terms:\n                print('        {}'.format(term))"}
{"i": 98, "got": "def get_common_terms(*api_envs):\n    \"\"\"pass\"\"\"\n    common_terms = []\n    wordsets = get_user_sets(*api_envs)\n    for wordset1, wordset2 in combinations(wordsets, 2):\n        common = wordset1.has_common(wordset2)\n        if common:\n            common_terms.append((wordset1.title, wordset2.title, common))\n    return common_terms"}
{"i": 99, "got": "def print_common_terms(common_terms):\n    \"\"\"pass\"\"\"\n    if not common_terms:\n        print('No duplicates')\n        return\n    for set_pair in common_terms:\n        set1, set2, terms = set_pair\n        print('{} and {} have in common:'.format(set1, set2))\n        for term in terms:\n            print('    {}'.format(term))"}
{"i": 100, "got": "def run(entry_point, drivers, loop=None):\n    \"\"\"pass\"\"\"\n    program = setup(entry_point, drivers)\n    dispose = program.run()\n    if loop == None:\n        loop = asyncio.get_event_loop()\n    loop.run_forever()\n    dispose()"}
{"i": 101, "got": "def compare_schemas(one, two):\n    \"\"\"pass\"\"\"\n    one = _normalize_string_type(one)\n    two = _normalize_string_type(two)\n    _assert_same_types(one, two)\n    if isinstance(one, list):\n        return _compare_lists(one, two)\n    elif isinstance(one, dict):\n        return _compare_dicts(one, two)\n    elif isinstance(one, SCALAR_TYPES):\n        return one == two\n    elif one is None:\n        return one is two\n    else:\n        raise RuntimeError('Not allowed type \"{type}\"'.format(type=type(one).__name__))"}
{"i": 102, "got": "def is_ecma_regex(regex):\n    \"\"\"pass\"\"\"\n    parts = regex.split('/')\n    if len(parts) == 1:\n        return False\n    elif len(parts) < 3:\n        raise ValueError(\"Given regex isn't ECMA regex nor Python regex.\")\n    else:\n        parts.pop()\n        parts.append('')\n        raw_regex = '/'.join(parts)\n        if raw_regex.startswith('/') and raw_regex.endswith('/'):\n            return True\n        else:\n            return False"}
{"i": 103, "got": "def convert_ecma_regex_to_python(value):\n    \"\"\"pass\"\"\"\n    if not is_ecma_regex(value):\n        return PythonRegex(value, [])\n    parts = value.split('/')\n    flags = parts.pop()\n    try:\n        result_flags = [ECMA_TO_PYTHON_FLAGS[f] for f in flags]\n    except KeyError:\n        raise ValueError('Wrong flags \"{}\".'.format(flags))\n    return PythonRegex('/'.join(parts[1:]), result_flags)"}
{"i": 104, "got": "def convert_python_regex_to_ecma(value, flags=[]):\n    \"\"\"pass\"\"\"\n    if is_ecma_regex(value):\n        return value\n    result_flags = [PYTHON_TO_ECMA_FLAGS[f] for f in flags]\n    result_flags = ''.join(result_flags)\n    return '/{value}/{flags}'.format(value=value, flags=result_flags)"}
{"i": 105, "got": "def populate(self, **values):\n    \"\"\"pass\"\"\"\n    values = values.copy()\n    fields = list(self.iterate_with_name())\n    for _, structure_name, field in fields:\n        if structure_name in values:\n            field.__set__(self, values.pop(structure_name))\n    for name, _, field in fields:\n        if name in values:\n            field.__set__(self, values.pop(name))"}
{"i": 106, "got": "def get_field(self, field_name):\n    \"\"\"pass\"\"\"\n    for attr_name, field in self:\n        if field_name == attr_name:\n            return field\n    raise errors.FieldNotFound('Field not found', field_name)"}
{"i": 107, "got": "def write(self, rows, keyed=False):\n    \"\"\"pass\"\"\"\n    for row in rows:\n        keyed_row = row\n        if not keyed:\n            keyed_row = dict(zip(self.__schema.field_names, row))\n        keyed_row = self.__convert_row(keyed_row)\n        if self.__check_existing(keyed_row):\n            for wr in self.__insert():\n                yield wr\n            ret = self.__update(keyed_row)\n            if ret is not None:\n                yield WrittenRow(keyed_row, True, ret if self.__autoincrement else None)\n        else:\n            self.__buffer.append(keyed_row)\n            while len(self.__buffer) > BUFFER_SIZE:\n                for wr in self.__insert():\n                    yield wr\n    for wr in self.__insert():\n        yield wr"}
{"i": 108, "got": "def __prepare_bloom(self):\n    \"\"\"pass\"\"\"\n    self.__bloom = pybloom_live.ScalableBloomFilter()\n    columns = [getattr(self.__table.c, key) for key in self.__update_keys]\n    keys = select(columns).execution_options(stream_results=True).execute()\n    for key in keys:\n        self.__bloom.add(tuple(key))"}
{"i": 109, "got": "def __insert(self):\n    \"\"\"pass\"\"\"\n    if len(self.__buffer) > 0:\n        statement = self.__table.insert()\n        if self.__autoincrement:\n            statement = statement.returning(getattr(self.__table.c, self.__autoincrement))\n            statement = statement.values(self.__buffer)\n            res = statement.execute()\n            for id in res:\n                row = self.__buffer.pop(0)\n                yield WrittenRow(row, False, id)\n        else:\n            statement.execute(self.__buffer)\n            for row in self.__buffer:\n                yield WrittenRow(row, False, None)\n        self.__buffer = []"}
{"i": 110, "got": "def __update(self, row):\n    \"\"\"pass\"\"\"\n    expr = self.__table.update().values(row)\n    for key in self.__update_keys:\n        expr = expr.where(getattr(self.__table.c, key) == row[key])\n    if self.__autoincrement:\n        expr = expr.returning(getattr(self.__table.c, self.__autoincrement))\n    res = expr.execute()\n    if res.rowcount > 0:\n        if self.__autoincrement:\n            first = next(iter(res))\n            last_row_id = first[0]\n            return last_row_id\n        else:\n            return 0"}
{"i": 111, "got": "def __check_existing(self, row):\n    \"\"\"pass\"\"\"\n    if self.__update_keys is not None:\n        key = tuple((row[key] for key in self.__update_keys))\n        if key in self.__bloom:\n            return True\n        else:\n            self.__bloom.add(key)\n            return False\n    else:\n        return False"}
{"i": 112, "got": "def buckets(self):\n    \"\"\"pass\"\"\"\n    buckets = []\n    for table in self.__metadata.sorted_tables:\n        bucket = self.__mapper.restore_bucket(table.name)\n        if bucket is not None:\n            buckets.append(bucket)\n    return buckets"}
{"i": 113, "got": "def open_hierarchy(self, path, relative_to_object_id, object_id, create_file_type=0):\n    \"\"\"pass\"\"\"\n    try:\n        return self.process.OpenHierarchy(path, relative_to_object_id, '', create_file_type)\n    except Exception as e:\n        print(e)\n        print('Could not Open Hierarchy')"}
{"i": 114, "got": "def create_new_page(self, section_id, new_page_style=0):\n    \"\"\"pass\"\"\"\n    try:\n        self.process.CreateNewPage(section_id, '', new_page_style)\n    except Exception as e:\n        print(e)\n        print('Unable to create the page')"}
{"i": 115, "got": "def get_page_content(self, page_id, page_info=0):\n    \"\"\"pass\"\"\"\n    try:\n        return self.process.GetPageContent(page_id, '', page_info)\n    except Exception as e:\n        print(e)\n        print('Could not get Page Content')\n        return None"}
{"i": 116, "got": "def publish(self, hierarchy_id, target_file_path, publish_format, clsid_of_exporter=''):\n    \"\"\"pass\"\"\"\n    try:\n        self.process.Publish(hierarchy_id, target_file_path, publish_format, clsid_of_exporter)\n    except Exception as e:\n        print(e)\n        print('Could not Publish')"}
{"i": 117, "got": "def get_special_location(self, special_location=0):\n    \"\"\"pass\"\"\"\n    try:\n        return self.process.GetSpecialLocation(special_location)\n    except Exception as e:\n        print(e)\n        print('Could not retreive special location')\n        return None"}
{"i": 118, "got": "def memory():\n    \"\"\"pass\"\"\"\n    mem_info = dict()\n    for k, v in psutil.virtual_memory()._asdict().items():\n        mem_info[k] = int(v)\n    return mem_info"}
{"i": 119, "got": "def get_chunk_size(N, n):\n    \"\"\"pass\"\"\"\n    mem_free = memory()['free']\n    if mem_free > 60000000:\n        chunk_size = int((mem_free - 10000000) * 1000 / (4 * n * N))\n    elif mem_free > 40000000:\n        chunk_size = int((mem_free - 7000000) * 1000 / (4 * n * N))\n    elif mem_free > 14000000:\n        chunk_size = int((mem_free - 2000000) * 1000 / (4 * n * N))\n    elif mem_free > 8000000:\n        chunk_size = int((mem_free - 1400000) * 1000 / (4 * n * N))\n    elif mem_free > 2000000:\n        chunk_size = int((mem_free - 900000) * 1000 / (4 * n * N))\n    elif mem_free > 1000000:\n        chunk_size = int((mem_free - 400000) * 1000 / (4 * n * N))\n    else:\n        print('\\nERROR: Cluster_Ensembles: get_chunk_size: this machine does not have enough free memory resources to perform ensemble clustering.\\n')\n        sys.exit(1)\n    return chunk_size"}
{"i": 120, "got": "def get_compression_filter(byte_counts):\n    \"\"\"pass\"\"\"\n    assert isinstance(byte_counts, numbers.Integral) and byte_counts > 0\n    if 2 * byte_counts > 1000 * memory()['free']:\n        try:\n            FILTERS = tables.filters(complevel=5, complib='blosc', shuffle=True, least_significant_digit=6)\n        except tables.FiltersWarning:\n            FILTERS = tables.filters(complevel=5, complib='lzo', shuffle=True, least_significant_digit=6)\n    else:\n        FILTERS = None\n    return FILTERS"}
{"i": 121, "got": "def build_hypergraph_adjacency(cluster_runs):\n    \"\"\"pass\"\"\"\n    N_runs = cluster_runs.shape[0]\n    hypergraph_adjacency = create_membership_matrix(cluster_runs[0])\n    for i in range(1, N_runs):\n        hypergraph_adjacency = scipy.sparse.vstack([hypergraph_adjacency, create_membership_matrix(cluster_runs[i])], format='csr')\n    return hypergraph_adjacency"}
{"i": 122, "got": "def store_hypergraph_adjacency(hypergraph_adjacency, hdf5_file_name):\n    \"\"\"pass\"\"\"\n    assert hypergraph_adjacency.__class__ == scipy.sparse.csr.csr_matrix\n    byte_counts = hypergraph_adjacency.data.nbytes + hypergraph_adjacency.indices.nbytes + hypergraph_adjacency.indptr.nbytes\n    FILTERS = get_compression_filter(byte_counts)\n    with tables.open_file(hdf5_file_name, 'r+') as fileh:\n        for par in ['data', 'indices', 'indptr', 'shape']:\n            try:\n                n = getattr(fileh.root.consensus_group, par)\n                n._f_remove()\n            except AttributeError:\n                pass\n            array = np.array(getattr(hypergraph_adjacency, par))\n            atom = tables.Atom.from_dtype(array.dtype)\n            ds = fileh.create_carray(fileh.root.consensus_group, par, atom, array.shape, filters=FILTERS)\n            ds[:] = array"}
{"i": 123, "got": "def load_hypergraph_adjacency(hdf5_file_name):\n    \"\"\"pass\"\"\"\n    with tables.open_file(hdf5_file_name, 'r+') as fileh:\n        pars = []\n        for par in ['data', 'indices', 'indptr', 'shape']:\n            pars.append(getattr(fileh.root.consensus_group, par).read())\n    hypergraph_adjacency = scipy.sparse.csr_matrix(tuple(pars[:3]), shape=pars[3])\n    return hypergraph_adjacency"}
{"i": 124, "got": "def obfuscate(p, action):\n    \"\"\"pass\"\"\"\n    key = 'ru7sll3uQrGtDPcIW3okutpFLo6YYtd5bWSpbZJIopYQ0Du0a1WlhvJOaZEH'\n    s = list()\n    if action == 'store':\n        if PY2:\n            for i in range(len(p)):\n                kc = key[i % len(key)]\n                ec = chr((ord(p[i]) + ord(kc)) % 256)\n                s.append(ec)\n        else:\n            return base64.urlsafe_b64encode(p.encode()).decode()\n    elif PY2:\n        e = base64.urlsafe_b64decode(p)\n        for i in range(len(e)):\n            kc = key[i % len(key)]\n            dc = chr((256 + ord(e[i]) - ord(kc)) % 256)\n            s.append(dc)\n        return ''.join(s)\n    else:\n        e = base64.urlsafe_b64decode(p)\n        return e.decode()"}
{"i": 125, "got": "def _config_bootstrap(self):\n    \"\"\"pass\"\"\"\n    if not os.path.exists(CONFIG_PATH):\n        os.makedirs(CONFIG_PATH)\n    if not os.path.exists(CONFIG_FILE):\n        json.dump(CONFIG_DEFAULTS, open(CONFIG_FILE, 'w'), indent=4, separators=(',', ': '))\n    config = CONFIG_DEFAULTS\n    if self._email and self._password:\n        config['email'] = self._email\n        config['password'] = str(obfuscate(self._password, 'store'))\n        self._log.debug('Caching authentication in config file')\n        json.dump(config, open(CONFIG_FILE, 'w'), indent=4, separators=(',', ': '))\n    else:\n        config = json.load(open(CONFIG_FILE))\n        if config.get('py2', PY2) != PY2:\n            raise Exception('Python versions have changed. Please run `setup` again to reconfigure the client.')\n        if config['email'] and config['password']:\n            self._email = config['email']\n            self._password = obfuscate(str(config['password']), 'fetch')\n            self._log.debug('Loaded authentication from config file')"}
{"i": 126, "got": "def _session_check(self):\n    \"\"\"pass\"\"\"\n    if not os.path.exists(SESSION_FILE):\n        self._log.debug('Session file does not exist')\n        return False\n    with open(SESSION_FILE, 'rb') as f:\n        cookies = requests.utils.cookiejar_from_dict(pickle.load(f))\n        self._session.cookies = cookies\n        self._log.debug('Loaded cookies from session file')\n    response = self._session.get(url=self.TEST_URL, headers=self.HEADERS)\n    if self.TEST_KEY in str(response.content):\n        self._log.debug('Session file appears invalid')\n        return False\n    else:\n        self._is_authenticated = True\n        self._process_state()\n        return True"}
{"i": 127, "got": "def _logger(self):\n    \"\"\"pass\"\"\"\n    logger = logging.getLogger(self.NAME)\n    logger.setLevel(self.LOG_LEVEL)\n    shandler = logging.StreamHandler(sys.stdout)\n    fmt = '\\x1b[1;32m%(levelname)-5s %(module)s:%(funcName)s():'\n    fmt += '%(lineno)d %(asctime)s\\x1b[0m| %(message)s'\n    shandler.setFormatter(logging.Formatter(fmt))\n    logger.addHandler(shandler)\n    return logger"}
{"i": 128, "got": "def set_log_level(self, level):\n    \"\"\"pass\"\"\"\n    if level == 'info':\n        level = logging.INFO\n    if level == 'debug':\n        level = logging.DEBUG\n    if level == 'error':\n        level = logging.ERROR\n    self._log.setLevel(level)"}
{"i": 129, "got": "def _process_state(self):\n    \"\"\"pass\"\"\"\n    self._log.debug('Capturing state from the request')\n    response = self._session.get(url=self.ALERTS_URL, headers=self.HEADERS)\n    soup = BeautifulSoup(response.content, 'html.parser')\n    for i in soup.findAll('script'):\n        if i.text.find('window.STATE') == -1:\n            continue\n        state = json.loads(i.text[15:-1])\n        if state != '':\n            self._state = state\n            self._log.debug('State value set: %s' % self._state)\n    return self._state"}
{"i": 130, "got": "def search_packages_info(query):\n    \"\"\"pass\"\"\"\n    installed = {}\n    for p in pkg_resources.working_set:\n        installed[canonicalize_name(p.project_name)] = p\n    query_names = [canonicalize_name(name) for name in query]\n    for dist in [installed[pkg] for pkg in query_names if pkg in installed]:\n        package = {'name': dist.project_name, 'version': dist.version, 'location': dist.location, 'requires': [dep.project_name for dep in dist.requires()]}\n        file_list = None\n        if isinstance(dist, pkg_resources.DistInfoDistribution):\n            if dist.has_metadata('RECORD'):\n                lines = dist.get_metadata_lines('RECORD')\n                paths = [l.split(',')[0] for l in lines]\n                paths = [os.path.join(dist.location, p) for p in paths]\n                file_list = [os.path.relpath(p, dist.location) for p in paths]\n        elif dist.has_metadata('installed-files.txt'):\n            paths = dist.get_metadata_lines('installed-files.txt')\n            paths = [os.path.join(dist.egg_info, p) for p in paths]\n            file_list = [os.path.relpath(p, dist.location) for p in paths]\n        if file_list:\n            package['files'] = sorted(file_list)\n        yield package"}
{"i": 131, "got": "def process_view(self, request, view_func, view_args, view_kwargs):\n    \"\"\"pass\"\"\"\n    view_keys = list(VIEW_METHOD_DATA.keys())\n    for key in view_keys:\n        del VIEW_METHOD_DATA[key]\n    self.view_data = {}\n    try:\n        cbv = view_func.view_class\n    except AttributeError:\n        cbv = False\n    if cbv:\n        self.view_data['cbv'] = True\n        klass = view_func.view_class\n        self.view_data['bases'] = [base.__name__ for base in inspect.getmro(klass)]\n        for member in inspect.getmembers(view_func.view_class):\n            if member[0] in VIEW_METHOD_WHITEIST and member[0] not in PATCHED_METHODS[klass]:\n                decorate_method(klass, member[0])\n                PATCHED_METHODS[klass].append(member[0])"}
{"i": 132, "got": "def process_response(self, request, response):\n    \"\"\"pass\"\"\"\n    if not settings.DEBUG:\n        return response\n    content_encoding = response.get('Content-Encoding', '')\n    content_type = response.get('Content-Type', '').split(';')[0]\n    if any((getattr(response, 'streaming', False), 'gzip' in content_encoding, content_type not in _HTML_TYPES)):\n        return response\n    content = force_text(response.content, encoding=settings.DEFAULT_CHARSET)\n    pattern = re.escape('</body>')\n    bits = re.split(pattern, content, flags=re.IGNORECASE)\n    if len(bits) > 1:\n        bits[-2] += debug_payload(request, response, self.view_data)\n        response.content = '</body>'.join(bits)\n        if response.get('Content-Length', None):\n            response['Content-Length'] = len(response.content)\n    return response"}
{"i": 133, "got": "def get_job_class(klass_str):\n    \"\"\"pass\"\"\"\n    mod_name, klass_name = klass_str.rsplit('.', 1)\n    try:\n        mod = importlib.import_module(mod_name)\n    except ImportError as e:\n        logger.error(\"Error importing job module %s: '%s'\", mod_name, e)\n        return None\n    try:\n        klass = getattr(mod, klass_name)\n    except AttributeError:\n        logger.error(\"Module '%s' does not define a '%s' class\", mod_name, klass_name)\n        return None\n    else:\n        return klass"}
{"i": 134, "got": "def get(self, *raw_args, **raw_kwargs):\n    \"\"\"pass\"\"\"\n    args = self.prepare_args(*raw_args)\n    kwargs = self.prepare_kwargs(**raw_kwargs)\n    key = self.key(*args, **kwargs)\n    item = self.cache.get(key)\n    call = Call(args=raw_args, kwargs=raw_kwargs)\n    if item is None:\n        if self.should_missing_item_be_fetched_synchronously(*args, **kwargs):\n            logger.debug(\"Job %s with key '%s' - cache MISS - running synchronous refresh\", self.class_path, key)\n            result = self.refresh(*args, **kwargs)\n            return self.process_result(result, call=call, cache_status=self.MISS, sync_fetch=True)\n        else:\n            logger.debug(\"Job %s with key '%s' - cache MISS - triggering async refresh and returning empty result\", self.class_path, key)\n            result = self.empty()\n            self.store(key, self.timeout(*args, **kwargs), result)\n            self.async_refresh(*args, **kwargs)\n            return self.process_result(result, call=call, cache_status=self.MISS, sync_fetch=False)\n    expiry, data = item\n    delta = time.time() - expiry\n    if delta > 0:\n        if self.should_stale_item_be_fetched_synchronously(delta, *args, **kwargs):\n            logger.debug(\"Job %s with key '%s' - STALE cache hit - running synchronous refresh\", self.class_path, key)\n            result = self.refresh(*args, **kwargs)\n            return self.process_result(result, call=call, cache_status=self.STALE, sync_fetch=True)\n        else:\n            logger.debug(\"Job %s with key '%s' - STALE cache hit - triggering async refresh and returning stale result\", self.class_path, key)\n            timeout = self.timeout(*args, **kwargs)\n            self.store(key, timeout, data)\n            self.async_refresh(*args, **kwargs)\n            return self.process_result(data, call=call, cache_status=self.STALE, sync_fetch=False)\n    else:\n        logger.debug(\"Job %s with key '%s' - cache HIT\", self.class_path, key)\n        return self.process_result(data, call=call, cache_status=self.HIT)"}
{"i": 135, "got": "def invalidate(self, *raw_args, **raw_kwargs):\n    \"\"\"pass\"\"\"\n    args = self.prepare_args(*raw_args)\n    kwargs = self.prepare_kwargs(**raw_kwargs)\n    key = self.key(*args, **kwargs)\n    item = self.cache.get(key)\n    if item is not None:\n        expiry, data = item\n        self.store(key, self.timeout(*args, **kwargs), data)\n        self.async_refresh(*args, **kwargs)"}
{"i": 136, "got": "def delete(self, *raw_args, **raw_kwargs):\n    \"\"\"pass\"\"\"\n    args = self.prepare_args(*raw_args)\n    kwargs = self.prepare_kwargs(**raw_kwargs)\n    key = self.key(*args, **kwargs)\n    item = self.cache.get(key)\n    if item is not None:\n        self.cache.delete(key)"}
{"i": 137, "got": "def raw_get(self, *raw_args, **raw_kwargs):\n    \"\"\"pass\"\"\"\n    args = self.prepare_args(*raw_args)\n    kwargs = self.prepare_kwargs(**raw_kwargs)\n    key = self.key(*args, **kwargs)\n    return self.cache.get(key)"}
{"i": 138, "got": "def set(self, *raw_args, **raw_kwargs):\n    \"\"\"pass\"\"\"\n    if self.set_data_kwarg in raw_kwargs:\n        data = raw_kwargs.pop(self.set_data_kwarg)\n    else:\n        raw_args = list(raw_args)\n        data = raw_args.pop()\n    args = self.prepare_args(*raw_args)\n    kwargs = self.prepare_kwargs(**raw_kwargs)\n    key = self.key(*args, **kwargs)\n    expiry = self.expiry(*args, **kwargs)\n    logger.debug(\"Setting %s cache with key '%s', args '%r', kwargs '%r', expiry '%r'\", self.class_path, key, args, kwargs, expiry)\n    self.store(key, expiry, data)"}
{"i": 139, "got": "def angle(v1, v2):\n    \"\"\"pass\"\"\"\n    v1_u = unit_vector(v1)\n    v2_u = unit_vector(v2)\n    return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))"}
{"i": 140, "got": "def keep_high_angle(vertices, min_angle_deg):\n    \"\"\"pass\"\"\"\n    accepted = []\n    v = vertices\n    v1 = v[1] - v[0]\n    accepted.append((v[0][0], v[0][1]))\n    for i in range(1, len(v) - 2):\n        v2 = v[i + 1] - v[i - 1]\n        diff_angle = np.fabs(angle(v1, v2) * 180.0 / np.pi)\n        if diff_angle > min_angle_deg:\n            accepted.append((v[i][0], v[i][1]))\n            v1 = v[i] - v[i - 1]\n    accepted.append((v[-1][0], v[-1][1]))\n    return np.array(accepted, dtype=vertices.dtype)"}
{"i": 141, "got": "def set_contourf_properties(stroke_width, fcolor, fill_opacity, contour_levels, contourf_idx, unit):\n    \"\"\"pass\"\"\"\n    return {'stroke': fcolor, 'stroke-width': stroke_width, 'stroke-opacity': 1, 'fill': fcolor, 'fill-opacity': fill_opacity, 'title': '%.2f' % contour_levels[contourf_idx] + ' ' + unit}"}
{"i": 142, "got": "def contour_to_geojson(contour, geojson_filepath=None, min_angle_deg=None, ndigits=5, unit='', stroke_width=1, geojson_properties=None, strdump=False, serialize=True):\n    \"\"\"pass\"\"\"\n    collections = contour.collections\n    contour_index = 0\n    line_features = []\n    for collection in collections:\n        color = collection.get_edgecolor()\n        for path in collection.get_paths():\n            v = path.vertices\n            if len(v) < 3:\n                continue\n            coordinates = keep_high_angle(v, min_angle_deg)\n            if ndigits:\n                coordinates = np.around(coordinates, ndigits)\n            line = LineString(coordinates.tolist())\n            properties = {'stroke-width': stroke_width, 'stroke': rgb2hex(color[0]), 'title': '%.2f' % contour.levels[contour_index] + ' ' + unit, 'level-value': float('%.6f' % contour.levels[contour_index]), 'level-index': contour_index}\n            if geojson_properties:\n                properties.update(geojson_properties)\n            line_features.append(Feature(geometry=line, properties=properties))\n        contour_index += 1\n    feature_collection = FeatureCollection(line_features)\n    return _render_feature_collection(feature_collection, geojson_filepath, strdump, serialize)"}
{"i": 143, "got": "def contourf_to_geojson_overlap(contourf, geojson_filepath=None, min_angle_deg=None, ndigits=5, unit='', stroke_width=1, fill_opacity=0.9, geojson_properties=None, strdump=False, serialize=True):\n    \"\"\"pass\"\"\"\n    polygon_features = []\n    contourf_idx = 0\n    for collection in contourf.collections:\n        color = collection.get_facecolor()\n        for path in collection.get_paths():\n            for coord in path.to_polygons():\n                if min_angle_deg:\n                    coord = keep_high_angle(coord, min_angle_deg)\n                coord = np.around(coord, ndigits) if ndigits else coord\n                polygon = Polygon(coordinates=[coord.tolist()])\n                fcolor = rgb2hex(color[0])\n                properties = set_contourf_properties(stroke_width, fcolor, fill_opacity, contourf.levels, contourf_idx, unit)\n                if geojson_properties:\n                    properties.update(geojson_properties)\n                feature = Feature(geometry=polygon, properties=properties)\n                polygon_features.append(feature)\n        contourf_idx += 1\n    feature_collection = FeatureCollection(polygon_features)\n    return _render_feature_collection(feature_collection, geojson_filepath, strdump, serialize)"}
{"i": 144, "got": "def contourf_to_geojson(contourf, geojson_filepath=None, min_angle_deg=None, ndigits=5, unit='', stroke_width=1, fill_opacity=0.9, geojson_properties=None, strdump=False, serialize=True):\n    \"\"\"pass\"\"\"\n    polygon_features = []\n    mps = []\n    contourf_idx = 0\n    for coll in contourf.collections:\n        color = coll.get_facecolor()\n        for path in coll.get_paths():\n            for coord in path.to_polygons():\n                if min_angle_deg:\n                    coord = keep_high_angle(coord, min_angle_deg)\n                coord = np.around(coord, ndigits) if ndigits else coord\n                op = MP(contourf.levels[conturf_idx], rgb2hex(color[0]))\n                if op in mps:\n                    for i, k in enumerate(mps):\n                        if k == op:\n                            mps[i].add_coords(coord.tolist())\n                else:\n                    op.add_coords(coord.tolist())\n                    mps.append(op)\n        contourf_idx += 1\n    contourf_idx = 0\n    for muli in mps:\n        polygon = muli.mpoly()\n        fcolor = muli.color\n        properties = set_contourf_properties(stroke_width, fcolor, fill_opacity, contourf.levels, contourf_idx, unit)\n        if geojson_properties:\n            properties.update(geojson_properties)\n        feature = Feature(geometry=polygon, properties=properties)\n        polygon_features.append(feature)\n        contourf_idx += 1\n    feature_collection = FeatureCollection(polygon_features)\n    return _render_feature_collection(feature_collection, geojson_filepath, strdump, serialize)"}
{"i": 145, "got": "def get_authorize_callback(endpoint, provider_id):\n    \"\"\"pass\"\"\"\n    endpoint_prefix = config_value('BLUEPRINT_NAME')\n    url = url_for(endpoint_prefix + '.' + endpoint, provider_id=provider_id)\n    return request.url_root[:-1] + url"}
{"i": 146, "got": "def delete_connection(self, **kwargs):\n    \"\"\"pass\"\"\"\n    conn = self.find_connection(**kwargs)\n    if not conn:\n        return False\n    self.delete(conn)\n    return True"}
{"i": 147, "got": "def delete_connections(self, **kwargs):\n    \"\"\"pass\"\"\"\n    rv = False\n    for c in self.find_connections(**kwargs):\n        self.delete(c)\n        rv = True\n    return rv"}
{"i": 148, "got": "def login(provider_id):\n    \"\"\"pass\"\"\"\n    provider = get_provider_or_404(provider_id)\n    callback_url = get_authorize_callback('login', provider_id)\n    post_login = request.form.get('next', get_post_login_redirect())\n    session[config_value('POST_OAUTH_LOGIN_SESSION_KEY')] = post_login\n    return provider.authorize(callback_url)"}
{"i": 149, "got": "def connect(provider_id):\n    \"\"\"pass\"\"\"\n    provider = get_provider_or_404(provider_id)\n    callback_url = get_authorize_callback('connect', provider_id)\n    allow_view = get_url(config_value('CONNECT_ALLOW_VIEW'))\n    pc = request.form.get('next', allow_view)\n    session[config_value('POST_OAUTH_CONNECT_SESSION_KEY')] = pc\n    return provider.authorize(callback_url)"}
{"i": 150, "got": "def remove_all_connections(provider_id):\n    \"\"\"pass\"\"\"\n    provider = get_provider_or_404(provider_id)\n    ctx = dict(provider=provider.name, user=current_user)\n    deleted = _datastore.delete_connections(user_id=current_user.get_id(), provider_id=provider_id)\n    if deleted:\n        after_this_request(_commit)\n        msg = ('All connections to %s removed' % provider.name, 'info')\n        connection_removed.send(current_app._get_current_object(), user=current_user._get_current_object(), provider_id=provider_id)\n    else:\n        msg = ('Unable to remove connection to %(provider)s' % ctx, 'error')\n    do_flash(*msg)\n    return redirect(request.referrer)"}
{"i": 151, "got": "def guess(filename, fallback='application/octet-stream'):\n    \"\"\"pass\"\"\"\n    guessed, encoding = mimetypes.guess_type(filename, strict=False)\n    if guessed is None:\n        return (fallback, encoding)\n    else:\n        return (guessed, encoding)"}
{"i": 152, "got": "def format_addresses(addrs):\n    \"\"\"pass\"\"\"\n    return ', '.join((formataddr(item) if isinstance(item, tuple) else item for item in addrs))"}
{"i": 153, "got": "def stringify_address(addr, encoding='utf-8'):\n    \"\"\"pass\"\"\"\n    if isinstance(addr, bytes_type):\n        return addr\n    try:\n        addr = addr.encode('ascii')\n    except UnicodeEncodeError:\n        if '@' in addr:\n            localpart, domain = addr.split('@', 1)\n            addr = b'@'.join([localpart.encode(encoding), domain.encode('idna')])\n        else:\n            addr = addr.encode(encoding)\n    return addr.decode('utf-8')"}
{"i": 154, "got": "def email(sender=None, receivers=(), cc=(), bcc=(), subject=None, content=None, encoding='utf8', attachments=()):\n    \"\"\"pass\"\"\"\n    enclosure = [HTML(content, encoding)]\n    enclosure.extend((Attachment(k) for k in attachments))\n    return Collection(enclosure, headers=headers.subject(subject), sender=headers.sender(sender), to=headers.to(*receivers), cc=headers.cc(*cc), bcc=headers.bcc(*bcc), date=headers.date(), message_id=headers.message_id())"}
{"i": 155, "got": "def postman(host=587, port=(None, None), auth=False, force_tls=None, options=None):\n    \"\"\"pass\"\"\"\n    return Postman(host=host, port=port, middlewares=[middleware.tls(force=force_tls), middleware.auth(*auth)], **options)"}
{"i": 156, "got": "def mime(self):\n    \"\"\"pass\"\"\"\n    mime = self.mime_object()\n    self.headers.prepare(mime)\n    return mime"}
{"i": 157, "got": "def get_existing_model(model_name):\n    \"\"\"pass\"\"\"\n    try:\n        model_cls = engine.get_document_cls(model_name)\n        log.debug('Model `{}` already exists. Using existing one'.format(model_name))\n        return model_cls\n    except ValueError:\n        log.debug('Model `{}` does not exist'.format(model_name))"}
{"i": 158, "got": "def prepare_relationship(config, model_name, raml_resource):\n    \"\"\"pass\"\"\"\n    if get_existing_model(model_name) is None:\n        plural_route = '/' + pluralize(model_name.lower())\n        route = '/' + model_name.lower()\n        for res in raml_resource.root.resources:\n            if res.method.upper() != 'POST':\n                continue\n            if res.path.endswith(plural_route) or res.path.endswith(route):\n                break\n        else:\n            raise ValueError('Model `{}` used in relationship is not defined'.format(model_name))\n        setup_data_model(config, res, model_name)"}
{"i": 159, "got": "def generate_model_cls(config, schema, model_name, raml_resource, es_based=True):\n    \"\"\"pass\"\"\"\n    from nefertari.authentication.models import AuthModelMethodsMixin\n    base_cls = engine.ESBaseDocument if es_based else engine.BaseDocument\n    model_name = str(model_name)\n    metaclass = type(base_cls)\n    auth_model = schema.get('_auth_model', False)\n    bases = []\n    if config.registry.database_acls:\n        from nefertari_guards import engine as guards_engine\n        bases.append(guards_engine.DocumentACLMixin)\n    if auth_model:\n        bases.append(AuthModelMethodsMixin)\n    bases.append(base_cls)\n    attrs = {'__tablename__': model_name.lower(), '_public_fields': schema.get('_public_fields') or [], '_auth_fields': schema.get('_auth_fields') or [], '_hidden_fields': schema.get('_hidden_fields') or [], '_nested_relationships': schema.get('_nested_relationships') or []}\n    if '_nesting_depth' in schema:\n        attrs['_nesting_depth'] = schema.get('_nesting_depth')\n    properties = schema.get('properties', {})\n    for field_name, props in properties.items():\n        if field_name in attrs:\n            continue\n        db_settings = props.get('_db_settings')\n        if db_settings is None:\n            continue\n        field_kwargs = db_settings.copy()\n        field_kwargs['required'] = bool(field_kwargs.get('required'))\n        for default_attr_key in ['default', 'onupdate']:\n            value = field_kwargs.get(default_attr_key)\n            if is_callable_tag(value):\n                field_kwargs[default_attr_key] = resolve_to_callable(value)\n        type_name = (field_kwargs.pop('type', 'string') or 'string').lower()\n        if not type_name in type_fields:\n            raise ValueError('Unknown type: {}'.format(type_name))\n        field_cls = type_fields[type_name]\n        if field_cls is engine.Relationship:\n            prepare_relationship(config, field_kwargs['document'], raml_resource)\n        if field_cls is engine.ForeignKeyField:\n            key = 'ref_column_type'\n            field_kwargs[key] = type_fields[field_kwargs[key]]\n        if field_cls is engine.ListField:\n            key = 'item_type'\n            field_kwargs[key] = type_fields[field_kwargs[key]]\n        attrs[field_name] = field_cls(**field_kwargs)\n    attrs.update(registry.mget(model_name))\n    model_cls = metaclass(model_name, tuple(bases), attrs)\n    setup_model_event_subscribers(config, model_cls, schema)\n    setup_fields_processors(config, model_cls, schema)\n    return (model_cls, auth_model)"}
{"i": 160, "got": "def setup_data_model(config, raml_resource, model_name):\n    \"\"\"pass\"\"\"\n    model_cls = get_existing_model(model_name)\n    schema = resource_schema(raml_resource)\n    if not schema:\n        raise Exception('Missing schema for model `{}`'.format(model_name))\n    if model_cls is not None:\n        return (model_cls, schema.get('_auth_model', False))\n    else:\n        log.info('Generating model class `{}`'.format(model_name))\n        return generate_model_cls(config, schema=schema, model_name=model_name, raml_resource=raml_resource)"}
{"i": 161, "got": "def handle_model_generation(config, raml_resource):\n    \"\"\"pass\"\"\"\n    model_name = generate_model_name(raml_resource)\n    try:\n        return setup_data_model(config, raml_resource, model_name)\n    except ValueError as ex:\n        raise ValueError('{}: {}'.format(model_name, str(ex)))"}
{"i": 162, "got": "def setup_model_event_subscribers(config, model_cls, schema):\n    \"\"\"pass\"\"\"\n    events_map = get_events_map()\n    model_events = schema.get('_event_handlers', {})\n    event_kwargs = {'model': model_cls}\n    for event_tag, subscribers in model_events.items():\n        type_, action = event_tag.split('_')\n        event_objects = events_map[type_][action]\n        if not isinstance(event_objects, list):\n            event_objects = [event_objects]\n        for sub_name in subscribers:\n            sub_func = resolve_to_callable(sub_name)\n            config.subscribe_to_events(sub_func, event_objects, **event_kwargs)"}
{"i": 163, "got": "def setup(app):\n    \"\"\"pass\"\"\"\n    import sphinxcontrib_django.docstrings\n    import sphinxcontrib_django.roles\n    sphinxcontrib_django.docstrings.setup(app)\n    sphinxcontrib_django.roles.setup(app)"}
{"i": 164, "got": "def patch_django_for_autodoc():\n    \"\"\"pass\"\"\"\n    ManagerDescriptor.__get__ = lambda self, *args, **kwargs: self.manager\n    models.QuerySet.__repr__ = lambda self: self.__class__.__name__"}
{"i": 165, "got": "def setup(app):\n    \"\"\"pass\"\"\"\n    from .patches import patch_django_for_autodoc\n    patch_django_for_autodoc()\n    app.connect('autodoc-process-docstring', improve_model_docstring)\n    app.connect('autodoc-skip-member', autodoc_skip)"}
{"i": 166, "got": "def autodoc_skip(app, what, name, obj, skip, options):\n    \"\"\"pass\"\"\"\n    if name in config.EXCLUDE_MEMBERS:\n        return True\n    elif name in config.INCLUDE_MEMBERS:\n        return False\n    else:\n        return skip"}
{"i": 167, "got": "def improve_model_docstring(app, what, name, obj, options, lines):\n    \"\"\"pass\"\"\"\n    if what == 'class':\n        _improve_class_docs(app, obj, lines)\n    elif what == 'attribute':\n        _improve_attribute_docs(obj, name, lines)\n    elif what == 'method':\n        _improve_method_docs(obj, name, lines)\n    return lines"}
{"i": 168, "got": "def _improve_class_docs(app, cls, lines):\n    \"\"\"pass\"\"\"\n    if issubclass(cls, models.Model):\n        _add_model_fields_as_params(app, cls, lines)\n    elif issubclass(cls, forms.Form):\n        _add_form_fields(cls, lines)"}
{"i": 169, "got": "def attr_names(cls) -> List[str]:\n    \"\"\"pass\"\"\"\n    return [k for k, v in cls.attr_types().items()]"}
{"i": 170, "got": "def elliptic_fourier_descriptors(contour, order=10, normalize=False):\n    \"\"\"pass\"\"\"\n    dxy = np.diff(contour, axis=0)\n    dt = np.sqrt((dxy ** 2).sum(axis=1))\n    t = np.concatenate([[0.0], np.cumsum(dt)])\n    T = t[-1]\n    phi = 2 * np.pi * t / T\n    coeffs = np.zeros((order, 4))\n    for n in _range(1, order + 1):\n        const = T / (2 * n * n * np.pi * np.pi)\n        phi_n = phi * n\n        d_cos_phi_n = np.cos(phi_n[1:]) - np.cos(phi_n[:-1])\n        d_sin_phi_n = np.sin(phi_n[1:]) - np.sin(phi_n[:-1])\n        a_n = const * np.sum(dxy[:, 0] / dt * d_cos_phi_n)\n        b_n = const * np.sum(dxy[:, 0] / dt * d_sin_phi_n)\n        c_n = const * np.sum(dxy[:, 1] / dt * d_cos_phi_n)\n        d_n = const * np.sum(dxy[:, 1] / dt * d_sin_phi_n)\n        coeffs[n - 1, :] = (a_n, b_n, c_n, d_n)\n    if normalize:\n        coeffs = normalize_efd(coeffs)\n    return coeffs"}
{"i": 171, "got": "def normalize_efd(coeffs, size_invariant=True):\n    \"\"\"pass\"\"\"\n    theta_1 = 0.5 * np.arctan2(2 * (coeffs[0, 0] * coeffs[0, 1] + coeffs[0, 2] * coeffs[0, 3]), coeffs[0, 0] ** 2 - coeffs[0, 1] ** 2 + coeffs[0, 2] ** 2 - coeffs[0, 3] ** 2)\n    for n in _range(1, coeffs.shape[0] + 1):\n        coeffs[n - 1, :] = np.dot(np.array([[coeffs[n - 1, 0], coeffs[n - 1, 1]], [coeffs[n - 1, 2], coeffs[n - 1, 3]]]), np.array([[np.cos(n * theta_1), -np.sin(n * theta_1)], [np.sin(n * theta_1), np.cos(n * theta_1)]]))\n    psi_1 = np.arctan2(coeffs[0, 2], coeffs[0, 0])\n    psi_rotation_matrix = np.array([[np.cos(psi_1), np.sin(psi_1)], [-np.sin(psi_1), np.cos(psi_1)]])\n    for n in _range(1, coeffs.shape[0] + 1):\n        coeffs[n - 1, :] = psi_rotation_matrix.dot(np.array([[coeffs[n - 1, 0], coeffs[n - 1, 1]], [coeffs[n - 1, 2], coeffs[n - 1, 3]]])).flatten()\n    if size_invariant:\n        coeffs /= np.abs(coeffs[0, 0])\n    return coeffs"}
{"i": 172, "got": "def calculate_dc_coefficients(contour):\n    \"\"\"pass\"\"\"\n    dxy = np.diff(contour, axis=0)\n    dt = np.sqrt((dxy ** 2).sum(axis=1))\n    t = np.concatenate([[0.0], np.cumsum(dt)])\n    T = t[-1]\n    xi = np.cumsum(dxy[:, 0]) - (dxy[:, 0] / dt) * t[1:]\n    A0 = 1 / T * np.sum((dxy[:, 0] / (2 * dt)) * np.diff(t ** 2) + xi * dt)\n    delta = np.cumsum(dxy[:, 1]) - dxy[:, 1] / dt * t[1:]\n    C0 = 1 / T * np.sum((dxy[:, 1] / (2 * dt)) * np.diff(t ** 2) + delta * dt)\n    return (contour[0, 0] + A0, contour[0, 1] + C0)"}
{"i": 173, "got": "def plot_efd(coeffs, locus=(0.0, 0.0), image=None, contour=None, n=300):\n    \"\"\"pass\"\"\"\n    try:\n        import matplotlib.pyplot as plt\n    except ImportError:\n        print('Cannot plot: matplotlib was not installed.')\n        return\n    N = coeffs.shape[0]\n    N_half = int(np.ceil(N / 2))\n    n_rows = 2\n    t = np.linspace(0, 1.0, n)\n    xt = np.ones((n,)) * locus[0]\n    yt = np.ones((n,)) * locus[1]\n    for n in _range(coeffs.shape[0]):\n        xt += coeffs[n, 0] * np.cos((2 * (n + 1) * np.pi * t))\n        yt += coeffs[n, 2] * np.cos((2 * (n + 1) * np.pi * t)) + coeffs[n, 3] * np.sin((2 * (n + 1) * np.pi * t))\n        ax = plt.subplot2grid((n_rows, N_half), (n // N_half, n % N_half))\n        ax.set_title(str(n + 1))\n        if contour is not None:\n            ax.plot(contour[:, 1], contour[:, 0], 'c--', linewidth=2)\n        ax.plot(yt, xt, 'r', linewidth=2)\n        if image is not None:\n            ax.imshow(image, plt.cm.gray)\n    plt.show()"}
{"i": 174, "got": "def _errcheck(result, func, arguments):\n    \"\"\"pass\"\"\"\n    if result != 0:\n        raise XdoException('Function {0} returned error code {1}'.format(func.__name__, result))"}
{"i": 175, "got": "def _gen_input_mask(mask):\n    \"\"\"pass\"\"\"\n    return input_mask(shift=bool(mask & MOD_Shift), lock=bool(mask & MOD_Lock), control=bool(mask & MOD_Control), mod1=bool(mask & MOD_Mod1), mod2=bool(mask & MOD_Mod2), mod3=bool(mask & MOD_Mod3), mod4=bool(mask & MOD_Mod4), mod5=bool(mask & MOD_Mod5))"}
{"i": 176, "got": "def move_mouse(self, x, y, screen=0):\n    \"\"\"pass\"\"\"\n    x = ctypes.c_int(x)\n    y = ctypes.c_int(y)\n    screen = ctypes.c_int(screen)\n    _libxdo.xdo_move_mouse(self._xdo, x, y, screen)"}
{"i": 177, "got": "def move_mouse_relative_to_window(self, window, x, y):\n    \"\"\"pass\"\"\"\n    _libxdo.xdo_move_mouse_relative_to_window(self._xdo, ctypes.c_ulong(window), x, y)"}
{"i": 178, "got": "def move_mouse_relative(self, x, y):\n    \"\"\"pass\"\"\"\n    _libxdo.xdo_move_mouse_relative(self._xdo, x, y)"}
{"i": 179, "got": "def mouse_down(self, window, button):\n    \"\"\"pass\"\"\"\n    _libxdo.xdo_mouse_down(self._xdo, ctypes.c_ulong(window), ctypes.c_int(button))"}
{"i": 180, "got": "def strip_punctuation_space(value):\n    \"\"\"pass\"\"\"\n\n    def strip_punctuation(string):\n        replacement_list = ((' .', '.'), (' :', ':'), ('( ', '('), (' )', ')'))\n        for match, replacement in replacement_list:\n            string = string.replace(match, replacement)\n        return string\n    if value == None:\n        return None\n    elif type(value) == list:\n        return [strip_punctuation(v) for v in value]\n    else:\n        return strip_punctuation(value)"}
{"i": 181, "got": "def join_sentences(string1, string2, glue='.'):\n    \"\"\"pass\"\"\"\n    if not string1 or string1 == '':\n        return string2\n    elif not string2 or string2 == '':\n        return string1\n    else:\n        new_string = string1.rstrip()\n        if not new_string.endswith(glue):\n            new_string += glue\n        new_string += ' ' + string2.lstrip()\n        return new_string"}
{"i": 182, "got": "def coerce_to_int(val, default=3735928559):\n    \"\"\"pass\"\"\"\n    try:\n        return int(val)\n    except (TypeError, ValueError):\n        if default != 3735928559:\n            return default\n        else:\n            return val"}
{"i": 183, "got": "def nullify(function):\n    \"\"\"pass\"\"\"\n\n    def wrapper(*args, **kwargs):\n        value = function(*args, **kwargs)\n        if type(value) == list and len(value) == 0:\n            return None\n        else:\n            return value\n    return wrapper"}
{"i": 184, "got": "def strippen(function):\n    \"\"\"pass\"\"\"\n\n    def wrapper(*args, **kwargs):\n        return strip_strings(function(*args, **kwargs))\n    return wrapper"}
{"i": 185, "got": "def inten(function):\n    \"\"\"pass\"\"\"\n\n    def wrapper(*args, **kwargs):\n        return coerce_to_int(function(*args, **kwargs))\n    return wrapper"}
{"i": 186, "got": "def connect(url, max_retries=None, **kwargs):\n    \"\"\"pass\"\"\"\n    client = AvaticaClient(url, max_retries=max_retries)\n    client.connect()\n    return Connection(client, **kwargs)"}
{"i": 187, "got": "def connect(self):\n    \"\"\"pass\"\"\"\n    logger.debug('Opening connection to %s:%s', self.url.hostname, self.url.port)\n    try:\n        self.connection = httplib.HTTPConnection(self.url.hostname, self.url.port)\n        self.connection.connect()\n    except (httplib.HTTPException, socket.error) as e:\n        raise errors.InterfaceError('Unable to connect to the specified service', e)"}
{"i": 188, "got": "def close(self):\n    \"\"\"pass\"\"\"\n    if self.connection is not None:\n        logger.debug('Closing connection to %s:%s', self.url.hostname, self.url.port)\n        try:\n            self.connection.close()\n        except httplib.HTTPException:\n            logger.warning('Error while closing connection', exc_info=True)\n        self.connection = None"}
{"i": 189, "got": "def connection_sync(self, connection_id, connProps=None):\n    \"\"\"pass\"\"\"\n    if connProps is None:\n        connProps = {}\n    request = requests_pb2.ConnectionSyncRequest()\n    request.connection_id = connection_id\n    request.conn_props.auto_commit = connProps.get('autoCommit', False)\n    request.conn_props.has_auto_commit = True\n    request.conn_props.read_only = connProps.get('readOnly', False)\n    request.conn_props.has_read_only = True\n    request.conn_props.transaction_isolation = connProps.get('transactionIsolation', 0)\n    request.conn_props.catalog = connProps.get('catalog', '')\n    request.conn_props.schema = connProps.get('schema', '')\n    response_data = self._apply(request)\n    response = responses_pb2.ConnectionSyncResponse()\n    response.ParseFromString(response_data)\n    return response.conn_props"}
{"i": 190, "got": "def open_connection(self, connection_id, info=None):\n    \"\"\"pass\"\"\"\n    request = requests_pb2.OpenConnectionRequest()\n    request.connection_id = connection_id\n    if info is not None:\n        for k, v in info.items():\n            request.info[k] = v\n    response_data = self._apply(request)\n    response = responses_pb2.OpenConnectionResponse()\n    response.ParseFromString(response_data)"}
{"i": 191, "got": "def close_connection(self, connection_id):\n    \"\"\"pass\"\"\"\n    request = requests_pb2.CloseConnectionRequest()\n    request.connection_id = connection_id\n    self._apply(request)"}
{"i": 192, "got": "def fit(self, X, y):\n    \"\"\"pass\"\"\"\n    self.X = X\n    self.y = y\n    if hasattr(self.gamma, '__iter__'):\n        self.gamma = self._optimize_gamma(self.gamma)\n    return self"}
{"i": 193, "got": "def predict(self, X):\n    \"\"\"pass\"\"\"\n    K = pairwise_kernels(self.X, X, metric=self.kernel, gamma=self.gamma)\n    return (K * self.y[:, None]).sum(axis=0) / K.sum(axis=0)"}
{"i": 194, "got": "def _compute_hidden_activations(self, X):\n    \"\"\"pass\"\"\"\n    self._compute_input_activations(X)\n    acts = self.input_activations_\n    if callable(self.activation_func):\n        args_dict = self.activation_args if self.activation_args else {}\n        X_new = self.activation_func(acts, **args_dict)\n    else:\n        func_name = self.activation_func\n        func = self._internal_activation_funcs[func_name]\n        X_new = func(acts, **self._extra_args)\n    return X_new"}
{"i": 195, "got": "def transform(self, X, y=None):\n    \"\"\"pass\"\"\"\n    if self.components_ is None:\n        raise ValueError('No components initialized')\n    return self._compute_hidden_activations(X)"}
{"i": 196, "got": "def _compute_radii(self):\n    \"\"\"pass\"\"\"\n    radii = self._get_user_components('radii')\n    if radii is None:\n        centers = self.components_['centers']\n        n_centers = centers.shape[0]\n        max_dist = np.max(pairwise_distances(centers))\n        radii = np.ones(n_centers) * max_dist / sqrt(2.0 * n_centers)\n    self.components_['radii'] = radii"}
{"i": 197, "got": "def _compute_centers(self, X, sparse, rs):\n    \"\"\"pass\"\"\"\n    centers = self._get_user_components('centers')\n    if centers is None:\n        n_features = X.shape[1]\n        if sparse:\n            fxr = range(n_features)\n            cols = [X.getcol(i) for i in fxr]\n            min_dtype = X.dtype.type(10000000000.0)\n            sp_min = lambda col: np.minimum(min_dtype, np.min(col.data))\n            min_Xs = np.array(map(sp_min, cols))\n            max_dtype = X.dtype.type(-10000000000.0)\n            sp_max = lambda col: np.maximum(max_dtype, np.max(col.data))\n            max_Xs = np.array(map(sp_max, cols))\n        else:\n            min_Xs = X.min(axis=0)\n            max_Xs = X.max(axis=0)\n        spans = max_Xs - min_Xs\n        ctrs_size = (self.n_hidden, n_features)\n        centers = min_Xs + spans * rs.uniform(0.0, 1.0, ctrs_size)\n    self.components_['centers'] = centers"}
{"i": 198, "got": "def compat_serializer_check_is_valid(serializer):\n    \"\"\"pass\"\"\"\n    if DRFVLIST[0] >= 3:\n        serializer.is_valid(raise_exception=True)\n    elif not serializer.is_valid():\n        serializers.ValidationError('The serializer raises a validation error')"}
{"i": 199, "got": "def compat_serializer_attr(serializer, obj):\n    \"\"\"pass\"\"\"\n    if DRFVLIST[0] == 3 and DRFVLIST[1] == 1:\n        for i in serializer.instance:\n            if i.id == obj.id:\n                return i\n        return None\n    else:\n        return obj"}
{"i": 200, "got": "def compat_get_paginated_response(view, page):\n    \"\"\"pass\"\"\"\n    if DRFVLIST[0] == 3 and DRFVLIST[1] >= 1:\n        from rest_messaging.serializers import ComplexMessageSerializer\n        serializer = ComplexMessageSerializer(page, many=True)\n        return view.get_paginated_response(serializer.data)\n    else:\n        serializer = view.get_pagination_serializer(page)\n        return Response(serializer.data)"}
{"i": 201, "got": "def compat_pagination_messages(cls):\n    \"\"\"pass\"\"\"\n    if DRFVLIST[0] == 3 and DRFVLIST[1] >= 1:\n        setattr(cls, 'pagination_class', MessagePagination)\n    else:\n        setattr(cls, 'paginate_by', getattr(settings, 'DJANGO_REST_MESSAGING_MESSAGES_PAGE_SIZE', 30))\n    return cls"}
{"i": 202, "got": "def get_participants(self, obj):\n    \"\"\"pass\"\"\"\n    if self.callback is None:\n        return [participant.id for participant in obj.participants.all()]\n    else:\n        return self.callback(obj)"}
{"i": 203, "got": "def get_is_notification(self, obj):\n    \"\"\"pass\"\"\"\n    try:\n        o = compat_serializer_attr(self, obj)\n        return o.is_notification\n    except Exception:\n        return False"}
{"i": 204, "got": "def process(self, quoted=False):\n    \"\"\"pass\"\"\"\n    self.p = urlparse(self.raw)\n    self.scheme = self.p.scheme\n    self.netloc = self.p.netloc\n    self.opath = self.p.path if not quoted else quote(self.p.path)\n    self.path = [x for x in self.opath.split('/') if x]\n    self.params = self.p.params\n    self.query = parse_qs(self.p.query, keep_blank_values=True)\n    self.fragment = self.p.fragment"}
{"i": 205, "got": "def fetch(self, url, encoding=None, force_refetch=False, nocache=False, quiet=True):\n    \"\"\"pass\"\"\"\n    try:\n        if not force_refetch and self.cache is not None and (url in self.cache):\n            logging.debug('Retrieving content from cache for {}'.format(url))\n            return self.cache.retrieve_blob(url, encoding)\n        encoded_url = WebHelper.encode_url(url)\n        req = Request(encoded_url, headers={'User-Agent': 'Mozilla/5.0'})\n        req.add_header('Accept-encoding', 'gzip, deflate')\n        getLogger().info('Fetching: {url} |'.format(url=url))\n        response = urlopen(req)\n        content = response.read()\n        if 'Content-Encoding' in response.info() and response.info().get('Content-Encoding') == 'gzip':\n            with gzip.open(BytesIO(content)) as gzfile:\n                content = gzfile.read()\n        if self.cache is not None and (not nocache) and (url not in self.cache):\n            self.cache.insert_blob(url, content)\n    except URLError as e:\n        if hasattr(e, 'reason'):\n            getLogger().exception('We failed to reach {}. Reason: {}'.format(url, e.reason))\n        elif hasattr(e, 'code'):\n            getLogger().exception(\"The server couldn't fulfill the request. Error code: {}\".format(e.code))\n        else:\n            getLogger().exception('Fetching error')\n        if not quiet:\n            raise\n    finally:\n        return content.decode(encoding) if content and encoding else content"}
{"i": 206, "got": "def download(self, url, path, force_refetch=False, nocache=False):\n    \"\"\"pass\"\"\"\n    if os.path.isfile(path):\n        getLogger().info('File exists, download task skipped -> {path}'.format(path=path))\n        return True\n    try:\n        getLogger().info('Downloading: {url} -> {path}'.format(url=url, path=path))\n        response = self.fetch(url, force_refetch=force_refetch, nocache=nocache)\n        if response is not None:\n            local_file = open(path, 'wb')\n            local_file.write(response)\n            local_file.close()\n            return True\n    except Exception as e:\n        if hasattr(e, 'reason'):\n            getLogger().exception('We failed to reach a server. Reason: %s' % (e.reason,))\n        elif hasattr(e, 'code'):\n            getLogger().exception(\"The server couldn't fulfill the request. Error code: {code}\".format(code=e.code))\n        else:\n            getLogger().exception('Unknown error: %s' % (e,))\n    return False"}
{"i": 207, "got": "def _platform(self) -> Optional[str]:\n    \"\"\"pass\"\"\"\n    try:\n        return str(self.journey.MainStop.BasicStop.Dep.Platform.text)\n    except AttributeError:\n        pass"}
{"i": 208, "got": "def _delay(self) -> int:\n    \"\"\"pass\"\"\"\n    try:\n        return int(self.journey.MainStop.BasicStop.Dep.Delay.text)\n    except AttributeError:\n        return 0"}
{"i": 209, "got": "def _departure(self) -> datetime:\n    \"\"\"pass\"\"\"\n    departure_time = datetime.strptime(self.journey.MainStop.BasicStop.Dep.Time.text, '%H:%M').time()\n    if (departure_time - self.now).time() > departure_time:\n        return datetime.combine(self.now.date(), departure_time)\n    else:\n        return datetime.combine(self.now.date() + timedelta(days=1), departure_time)"}
{"i": 210, "got": "def _extract(self, attribute) -> str:\n    \"\"\"pass\"\"\"\n    attr_data = self.journey.JourneyAttributeList.JourneyAttribute[self.attr_types.index(attribute)].Attribute\n    attr_variants = attr_data.xpath('AttributeVariant/@type')\n    data = attr_data.AttributeVariant[attr_variants.index('NORMAL')].Text.pyval\n    return str(data)"}
{"i": 211, "got": "def _info(self) -> Optional[str]:\n    \"\"\"pass\"\"\"\n    try:\n        return str(html.unescape(self.journey.InfoTextList.InfoText.get('text')))\n    except AttributeError:\n        pass"}
{"i": 212, "got": "def _info_long(self) -> Optional[str]:\n    \"\"\"pass\"\"\"\n    try:\n        return str(html.unescape(self.journey.InfoTextList.InfoText.get('textL')).replace('<br />', '\\n'))\n    except AttributeError:\n        pass"}
{"i": 213, "got": "def validate(style):\n    \"\"\"pass\"\"\"\n    try:\n        import jsonschema\n    except ImportError:\n        return\n    try:\n        jsonschema.validate(style, schema)\n    except jsonschema.ValidationError as exc:\n        new_exc = StyleValidationError(exc)\n        new_exc.__cause__ = None\n        raise new_exc"}
{"i": 214, "got": "def value_type(value):\n    \"\"\"pass\"\"\"\n    try:\n        keys = list(value.keys())\n    except AttributeError:\n        return 'simple'\n    if keys in ([], ['lookup'], ['re_lookup'], ['interval']):\n        return keys[0]\n    raise ValueError('Type of `value` could not be determined')"}
{"i": 215, "got": "def _register_mecab_loc(location):\n    \"\"\"pass\"\"\"\n    global MECAB_LOC\n    if not os.path.isfile(location):\n        logging.getLogger(__name__).warning('Provided mecab binary location does not exist {}'.format(location))\n    logging.getLogger(__name__).info('Mecab binary is switched to: {}'.format(location))\n    MECAB_LOC = location"}
{"i": 216, "got": "def run_mecab_process(content, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    encoding = 'utf-8' if not 'encoding' in kwargs else kwargs['encoding']\n    mecab_loc = kwargs['mecab_loc'] if 'mecab_loc' in kwargs else None\n    if mecab_loc is None:\n        mecab_loc = MECAB_LOC\n    proc_args = [mecab_loc]\n    if args:\n        proc_args.extend(args)\n    output = subprocess.run(proc_args, input=content.encode(encoding), stdout=subprocess.PIPE)\n    output_string = os.linesep.join(output.stdout.decode(encoding).splitlines())\n    return output_string"}
{"i": 217, "got": "def parse(content, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    if 'mecab_loc' not in kwargs and MECAB_PYTHON3 and ('MeCab' in globals()):\n        return MeCab.Tagger(*args).parse(content)\n    else:\n        return run_mecab_process([content], *args, **kwargs)"}
{"i": 218, "got": "def create_track(self, path_in_ipod=None, checksum=None):\n    \"\"\"pass\"\"\"\n    if bool(path_in_ipod) == bool(checksum):\n        raise Exception\n    if not path_in_ipod:\n        path_in_ipod = self.audiodb.get_voice(checksum)\n    track = Track(self, path_in_ipod=path_in_ipod)\n    return track"}
{"i": 219, "got": "def voice(self):\n    \"\"\"pass\"\"\"\n    dbid = self.lldb.dbid\n    text, lang = self._voiceoverdb.get_text_lang(dbid)\n    return (text, lang)"}
{"i": 220, "got": "def add(self, src):\n    \"\"\"pass\"\"\"\n    if not audio.get_type(src):\n        raise TypeError('The type of this file is not supported.')\n    return super().add(src)"}
{"i": 221, "got": "def _get_cmd(command, arguments):\n    \"\"\"pass\"\"\"\n    if arguments is None:\n        arguments = []\n    if command.endswith('.py') or command.endswith('.pyw'):\n        return [sys.executable, command] + list(arguments)\n    else:\n        return [command] + list(arguments)"}
{"i": 222, "got": "def argparse(argv, parser, arguments):\n    \"\"\"pass\"\"\"\n\n    def add_arg(parser, arg_spec):\n        parser.add_argument(arg_spec.name, help=arg_spec.help)\n        return parser\n    parse_request = parser.map(lambda i: ArgumentParser(description=i.description))(lambda parser, arg_def: add_arg(parser, arg_def)).last().combine_latest(argv.to_list(), lambda parser, args: (parser, args))\n\n    def subscribe(observer):\n\n        def on_next(value):\n            parser, args = value\n            try:\n                args = parser.parse_args(args)\n                for key, value in vars(args).items():\n                    observer.on_next(Argument(key=key, value=value))\n            except NameError as exc:\n                observer.on_error('{}\\n{}'.format(exc, parser.format_help()))\n        return parse_request.subscribe(on_next, observer.on_error, observer.on_completed)\n    return AnonymousObservable(subscribe)"}
{"i": 223, "got": "def qn(phi, *n):\n    \"\"\"pass\"\"\"\n    phi = np.ravel(phi)\n    n = np.asarray(n)\n    i_n_phi = np.zeros((n.size, phi.size), dtype=complex)\n    np.outer(n, phi, out=i_n_phi.imag)\n    qn = np.exp(i_n_phi, out=i_n_phi).sum(axis=1)\n    if qn.size == 1:\n        qn = qn[0]\n    return qn"}
{"i": 224, "got": "def correlation(self, n, k, error=False):\n    \"\"\"pass\"\"\"\n    self._calculate_corr(n, k)\n    corr_nk = self._corr[n][k]\n    if error:\n        self._calculate_corr_err(n, k)\n        return (corr_nk, self._corr_err[n][k])\n    else:\n        return corr_nk"}
{"i": 225, "got": "def cumulant(self, n, k, error=False):\n    \"\"\"pass\"\"\"\n    corr_nk = self.correlation(n, k, error=error)\n    if k == 2:\n        return corr_nk\n    elif k == 4:\n        corr_n2 = self.correlation(n, 2)\n        return corr_nk - 2 * corr_n2 * corr_n2"}
{"i": 226, "got": "def flow(self, n, k, error=False, imaginary='nan'):\n    \"\"\"pass\"\"\"\n    cnk = self.cumulant(n, k, error=error)\n    if error:\n        cnk, cnk_err = cnk\n    vnk_to_k = self._cnk_prefactor[k] * cnk\n    kinv = 1 / k\n    if vnk_to_k >= 0:\n        vnk = vnk_to_k ** kinv\n    elif imaginary == 'negative':\n        vnk = -1 * (vnk_to_k ** (-kinv))\n    elif imaginary == 'zero':\n        vnk = 0.0\n    else:\n        warnings.warn('Imaginary flow: returning NaN.', RuntimeWarning)\n        vnk = float('nan')\n    if k == 2 and error:\n        return (vnk, 0.5 / np.sqrt(abs(cnk)) * cnk_err)\n    else:\n        return vnk"}
{"i": 227, "got": "def _pdf(self, phi):\n    \"\"\"pass\"\"\"\n    pdf = np.inner(self._vn, np.cos(np.outer(phi, self._n)))\n    pdf *= 2.0\n    pdf += 1.0\n    return pdf"}
{"i": 228, "got": "def _uniform_phi(M):\n    \"\"\"pass\"\"\"\n    return np.random.uniform(-np.pi, np.pi, M)"}
{"i": 229, "got": "def smart_text(s, encoding='utf-8', strings_only=False, errors='strict'):\n    \"\"\"pass\"\"\"\n    if isinstance(s, six.text_type):\n        return s\n    elif strings_only and (not isinstance(s, six.string_types)):\n        return s\n    elif not isinstance(s, six.string_types):\n        if hasattr(s, '__unicode__'):\n            s = s.__unicode__()\n        elif six.PY3:\n            if isinstance(s, six.binary_type):\n                s = six.text_type(s, encoding, errors)\n            else:\n                s = six.text_type(s)\n        else:\n            s = six.text_type(six.binary_type(s), encoding, errors)\n    else:\n        s = s.decode(encoding, errors)\n    return s"}
{"i": 230, "got": "def smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):\n    \"\"\"pass\"\"\"\n    if isinstance(s, six.binary_type):\n        if encoding == 'utf-8':\n            return s\n        else:\n            return s.decode('utf-8', errors).encode(encoding, errors)\n    elif strings_only and (not isinstance(s, six.text_type)):\n        return s\n    elif not isinstance(s, six.string_types):\n        try:\n            if six.PY3:\n                return six.text_type(s).encode(encoding)\n            else:\n                return six.binary_type(s)\n        except UnicodeEncodeError:\n            return six.text_type(s).encode(encoding, errors)\n    else:\n        return s.encode(encoding, errors)"}
{"i": 231, "got": "def output(self, response, accepts):\n    \"\"\"pass\"\"\"\n    graph = self.get_graph(response)\n    if graph is not None:\n        mimetype, format = self.format_selector.decide(accepts, graph.context_aware)\n        if mimetype is None:\n            return self.make_406_response()\n        if 'text' in mimetype:\n            mimetype = mimetype + '; charset=utf-8'\n        serialized = graph.serialize(format=format)\n        response = self.make_new_response(response, mimetype, serialized)\n    return response"}
{"i": 232, "got": "def decorate(self, view):\n    \"\"\"pass\"\"\"\n    from functools import wraps\n\n    @wraps(view)\n    def decorated(*args, **kwargs):\n        response = view(*args, **kwargs)\n        accept = self.get_accept()\n        return self.output(response, accept)\n    return decorated"}
{"i": 233, "got": "def get(self, var, default=None):\n    \"\"\"pass\"\"\"\n    try:\n        return self.__get(var)\n    except (KeyError, IndexError):\n        return default"}
{"i": 234, "got": "def insert(self, var, value, index=None):\n    \"\"\"pass\"\"\"\n    current = self.__get(var)\n    if not isinstance(current, list):\n        raise KeyError('%s: is not a list' % var)\n    if index is None:\n        current.append(value)\n    else:\n        current.insert(index, value)\n    if self.auto_save:\n        self.save()"}
{"i": 235, "got": "def keys(self):\n    \"\"\"pass\"\"\"\n    s = set()\n    for config in self.__configs:\n        s |= config.keys()\n    return s"}
{"i": 236, "got": "def get(self, variable_path: str=None, default: t.Optional[t.Any]=None, coerce_type: t.Optional[t.Type]=None, coercer: t.Optional[t.Callable]=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if self.scope:\n        variable_path = '{0.scope}{0.path_separator}{1}'.format(self, variable_path)\n    if self.key_prefix:\n        variable_path = '{0.key_prefix}:{1}'.format(self, variable_path)\n    val = self.client.get(variable_path)\n    if val is None:\n        return default\n    if val.startswith(self.object_serialize_prefix):\n        _val = val[len(self.object_serialize_prefix):]\n        bundle = self.object_deserialize(_val)\n        if bundle == '':\n            return self.coerce(bundle, coerce_type=coerce_type, coercer=coercer)\n        else:\n            return bundle\n    if isinstance(val, bytes):\n        val = val.decode()\n    return self.coerce(val, coerce_type=coerce_type, coercer=coercer)"}
{"i": 237, "got": "def setup_logging(verbose=False, logger=None):\n    \"\"\"pass\"\"\"\n    if not verbose:\n        logging.getLogger('requests').setLevel(logging.WARNING)\n    format_ = '%(asctime)s %(levelname)-8s %(name)-40s %(message)s' if verbose else '%(message)s'\n    level = logging.DEBUG if verbose else logging.INFO\n    handler_stdout = logging.StreamHandler(sys.stdout)\n    handler_stdout.setFormatter(logging.Formatter(format_))\n    handler_stdout.setLevel(logging.DEBUG)\n    handler_stdout.addFilter(InfoFilter())\n    handler_stderr = logging.StreamHandler(sys.stderr)\n    handler_stderr.setFormatter(logging.Formatter(format_))\n    handler_stderr.setLevel(logging.WARNING)\n    root_logger = logging.getLogger(logger)\n    root_logger.setLevel(level)\n    root_logger.addHandler(handler_stdout)\n    root_logger.addHandler(handler_stderr)"}
{"i": 238, "got": "def with_log(func):\n    \"\"\"pass\"\"\"\n\n    @functools.wraps(func)\n    def wrapper(*args, **kwargs):\n        \"\"\"pass\"\"\"\n        decorator_logger = logging.getLogger('@with_log')\n        decorator_logger.debug('Entering %s() function call.', func.__name__)\n        log = kwargs.get('log', logging.getLogger(func.__name__))\n        try:\n            ret = func(*args, log=log, **kwargs)\n        finally:\n            decorator_logger.debug('Leaving %s() function call.', func.__name__)\n        return ret\n    return wrapper"}
{"i": 239, "got": "def get_arguments(argv=None, environ=None):\n    \"\"\"pass\"\"\"\n    name = 'appveyor-artifacts'\n    environ = environ or os.environ\n    require = getattr(pkg_resources, 'require')\n    commit, owner, pull_request, repo, tag = ('', '', '', '', '')\n    project = [p for p in require(name) if p.project_name == name][0]\n    version = project.version\n    args = docopt(__doc__, argv=argv or sys.argv[1:], version=version)\n    if environ.get('TRAVIS') == 'true':\n        commit = environ.get('TRAVIS_COMMIT', '')\n        owner = environ.get('TRAVIS_REPO_SLUG', '/').split('/')[0]\n        pull_request = environ.get('TRAVIS_PULL_REQUEST', '')\n        if pull_request == 'false':\n            pull_request = ''\n        repo = environ.get('TRAVIS_REPO_SLUG', '/').split('/')[1].replace('_', '-')\n        tag = environ.get('TRAVIS_TAG', '')\n    commit = args['--commit'] or commit\n    owner = args['--owner-name'] or owner\n    pull_request = args['--pull-request'] or pull_request\n    repo = args['--repo-name'] or repo\n    tag = args['--tag-name'] or tag\n    config = {'always_job_dirs': args['--always-job-dirs'], 'commit': commit, 'dir': args['--dir'] or '', 'ignore_errors': args['--ignore-errors'], 'job_name': args['--job-name'] or '', 'mangle_coverage': args['--mangle-coverage'], 'no_job_dirs': args['--no-job-dirs'] or '', 'owner': owner, 'pull_request': pull_request, 'raise': args['--raise'], 'repo': repo, 'tag': tag, 'verbose': args['--verbose']}\n    return config"}
{"i": 240, "got": "def query_api(endpoint, log):\n    \"\"\"pass\"\"\"\n    url = API_PREFIX + endpoint\n    headers = {'content-type': 'application/json'}\n    response = None\n    log.debug('Querying %s with headers %s.', url, headers)\n    for i in range(QUERY_ATTEMPTS):\n        try:\n            try:\n                response = requests.get(url, headers=headers, timeout=10)\n            except (requests.exceptions.ConnectTimeout, requests.exceptions.ReadTimeout, requests.Timeout):\n                log.error('Timed out waiting for reply from server.')\n                raise HandledError\n            except requests.ConnectionError:\n                log.error('Unable to connect to server.')\n                raise HandledError\n        except HandledError:\n            if i == QUERY_ATTEMPTS - 1:\n                raise\n            else:\n                log.warning('Network error, retrying in 1 second...')\n                time.sleep(1)\n    log.debug('Response status: %d', response.status_code)\n    log.debug('Response headers: %s', str(response.headers))\n    log.debug('Response text: %s', response.text)\n    if not response.ok:\n        message = response.json().get('message')\n        if message:\n            log.error('HTTP %d: %s', response.status_code, message)\n            raise HandledError\n        else:\n            log.error('HTTP %d: Unknown error: %s', response.status_code, response.text)\n            raise HandledError\n    try:\n        return response.json()\n    except ValueError:\n        log.error('Failed to parse JSON: %s', response.text)\n        raise HandledError"}
{"i": 241, "got": "def validate(config, log):\n    \"\"\"pass\"\"\"\n    if config['always_job_dirs'] and config['no_job_dirs']:\n        log.error('Contradiction: --always-job-dirs and --no-job-dirs used.')\n        raise HandledError\n    if config['commit']:\n        if not REGEX_COMMIT.match(config['commit']):\n            log.error('No or invalid git commit obtained.')\n            raise HandledError\n    if config['dir'] and (not os.path.isdir(config['dir'])):\n        log.error(\"Not a directory or doesn't exist: %s\", config['dir'])\n        raise HandledError\n    if config['no_job_dirs'] not in ('', 'rename', 'overwrite', 'skip'):\n        log.error('--no-job-dirs has invalid value. Check --help for valid values.')\n        raise HandledError\n    if not config['owner'] or not REGEX_GENERAL.match(config['owner']):\n        log.error('No or invalid repo owner name obtained.')\n        raise HandledError\n    if config['pull_request'] and (not config['pull_request'].isdigit()):\n        log.error('--pull-request is not a digit.')\n        raise HandledError\n    if config['repo'] and (not REGEX_GENERAL.match(config['repo'])):\n        log.error('No or invalid repo name obtained.')\n        raise HandledError\n    if config['tag'] and (not REGEX_GENERAL.match(config['tag'])):\n        log.error('Invalid git tag obtained.')\n        raise HandledError"}
{"i": 242, "got": "def query_build_version(config, log):\n    \"\"\"pass\"\"\"\n    url = '/projects/{0}/{1}/history?recordsNumber=10'.format(config['owner'], config['repo'])\n    log.debug('Querying AppVeyor history API for %s/%s...', config['owner'], config['repo'])\n    json_data = query_api(url)\n    if 'builds' not in json_data:\n        log.error('Bad JSON reply: \"builds\" key missing.')\n        raise HandledError\n    for build in json_data['builds']:\n        if config['tag'] and config['tag'] == build.get('tag'):\n            log.debug('This is a tag build.')\n        elif config['pull_request'] and config['pull_request'] == build.get('pullRequestId'):\n            log.debug('This is a pull request build.')\n        elif config['commit'] == build['commitId']:\n            log.debug('This is a branch build.')\n        else:\n            continue\n        log.debug('Build JSON dict: %s', str(build))\n        return build['version']\n    return None"}
{"i": 243, "got": "def incoming_messages(self) -> (t.List[t.Tuple[float, bytes]],):\n    \"\"\"pass\"\"\"\n    approximate_messages = self._receive_buffer.qsize()\n    messages = []\n    for _ in range(approximate_messages):\n        try:\n            messages.append(self._receive_buffer.get_nowait())\n        except queue.Empty:\n            break\n    return messages"}
{"i": 244, "got": "def _safe_get(mapping, key, default=None):\n    \"\"\"pass\"\"\"\n    try:\n        return mapping.get(key, default)\n    except AttributeError:\n        return default"}
{"i": 245, "got": "def strip_callables(row):\n    \"\"\"pass\"\"\"\n    callables = []\n    to_delete = []\n    to_add = []\n    for columns, value in row.items():\n        if isinstance(value, tuple):\n            initial, fn = value\n        else:\n            initial = NOTHING\n            fn = value\n        if callable(fn) or inspect.isgenerator(fn):\n            lgr.debug('Using %r as the initial value for columns %r in row %r', initial, columns, row)\n            if not isinstance(columns, tuple):\n                columns = (columns,)\n            else:\n                to_delete.append(columns)\n            for column in columns:\n                to_add.append((column, initial))\n            callables.append((columns, fn))\n    for column, value in to_add:\n        row[column] = value\n    for multi_columns in to_delete:\n        del row[multi_columns]\n    return callables"}
{"i": 246, "got": "def build(self, columns):\n    \"\"\"pass\"\"\"\n    self.columns = columns\n    default = dict(elements.default('default_'), **_safe_get(self.init_style, 'default_', {}))\n    self.style = elements.adopt({c: default for c in columns}, self.init_style)\n    self.style['default_'] = default\n    self.style['header_'] = self._compose('header_', {'align', 'width'})\n    self.style['aggregate_'] = self._compose('aggregate_', {'align', 'width'})\n    self.style['separator_'] = _safe_get(self.init_style, 'separator_', elements.default('separator_'))\n    lgr.debug('Validating style %r', self.style)\n    self.style['width_'] = _safe_get(self.init_style, 'width_', elements.default('width_'))\n    elements.validate(self.style)\n    self._setup_fields()\n    ngaps = len(self.columns) - 1\n    self.width_separtor = len(self.style['separator_']) * ngaps\n    lgr.debug('Calculated separator width as %d', self.width_separtor)"}
{"i": 247, "got": "def _compose(self, name, attributes):\n    \"\"\"pass\"\"\"\n    name_style = _safe_get(self.init_style, name, elements.default(name))\n    if self.init_style is not None and name_style is not None:\n        result = {}\n        for col in self.columns:\n            cstyle = {k: v for k, v in self.style[col].items() if k in attributes}\n            result[col] = dict(cstyle, **name_style)\n        return result"}
{"i": 248, "got": "def get_config(self):\n    \"\"\"pass\"\"\"\n    self.create_ssl_certs()\n    config = {'bootstrap_servers': self.get_brokers(), 'security_protocol': 'SSL', 'ssl_cafile': self.ssl['ca']['file'].name, 'ssl_certfile': self.ssl['cert']['file'].name, 'ssl_keyfile': self.ssl['key']['file'].name, 'ssl_check_hostname': False, 'ssl_password': None}\n    self.config.update(config)"}
{"i": 249, "got": "def get_brokers(self):\n    \"\"\"pass\"\"\"\n    return ['{}:{}'.format(parsedUrl.hostname, parsedUrl.port) for url in [urlparse(url) for url in self.kafka_url.split(',')]]"}
{"i": 250, "got": "def create_ssl_certs(self):\n    \"\"\"pass\"\"\"\n    for key, file in self.ssl.items():\n        file['file'] = self.create_temp_file(file['suffix'], file['content'])"}
{"i": 251, "got": "def create_temp_file(self, suffix, content):\n    \"\"\"pass\"\"\"\n    temp = tempfile.NamedTemporaryFile(suffix=suffix)\n    temp.write(content.encode('latin1').decode('unicode_escape').encode('utf-8'))\n    temp.seek(0)\n    return temp"}
{"i": 252, "got": "def prefix_topic(self, topics):\n    \"\"\"pass\"\"\"\n    if not self.topic_prefix or not topics:\n        return topics\n    elif not isinstance(topics, str) and isinstance(topics, collections.Iterable):\n        return [self.topic_prefix + topic for topic in topics]\n    else:\n        return self.topic_prefix + topics"}
{"i": 253, "got": "def send(self, topic, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    prefix_topic = self.heroku_kafka.prefix_topic(topic)\n    return super(HerokuKafkaProducer, self).send(prefix_topic, *args, **kwargs)"}
{"i": 254, "got": "def get(self, variable_path: str=None, default: t.Optional[t.Any]=None, coerce_type: t.Optional[t.Type]=None, coercer: t.Optional[t.Callable]=None, **kwargs):\n    \"\"\"pass\"\"\"\n    raise NotImplementedError"}
{"i": 255, "got": "def coerce(val=None, coerce_type=None, coercer: t.Optional[t.Callable]=t.Any) -> t.Any:\n    \"\"\"pass\"\"\"\n    if not (coerce_type or coercer):\n        return val\n    if coerce_type and type(val) is coerce_type:\n        return val\n    if coerce_type and coerce_type is bool and (not coercer):\n        coercer = coerce_str_to_bool\n    if coercer is None:\n        coercer = coerce_type\n    return coercer(val)"}
{"i": 256, "got": "def client(self):\n    \"\"\"pass\"\"\"\n    if self._client is not None:\n        return self._client\n    else:\n        self._client = self.get_client()\n        return self._client"}
{"i": 257, "got": "def write_uwsgi_ini_cfg(fp: t.IO, cfg: dict):\n    \"\"\"pass\"\"\"\n    fp.write('[uwsgi]\\n')\n    for key, val in cfg.items():\n        if isinstance(val, bool):\n            val = str(val).lower()\n        if isinstance(val, list):\n            for v in val:\n                fp.write(f'{key} = {v}\\n')\n        else:\n            fp.write(f'{key} = {val}\\n')"}
{"i": 258, "got": "def get(self, variable_path: str=None, default: t.Optional[t.Any]=None, coerce_type: t.Optional[t.Type]=None, coercer: t.Optional[t.Callable]=None, **kwargs) -> Any:\n    \"\"\"pass\"\"\"\n    if self.path_separator != self.consul_path_separator:\n        variable_path = variable_path.replace(self.path_separator, self.consul_path_separator)\n    if self.scope:\n        _scope = self.consul_path_separator.join(self.scope.split(self.path_separator))\n        variable_path = '{0}/{1}'.format(_scope, variable_path)\n    index, data = self.client.kv.get(variable_path, **kwargs)\n    if data is None:\n        return default\n    val = data['Value']\n    if val is None:\n        return val\n    if val.startswith(self.object_serialize_prefix):\n        _val = val[len(self.object_serialize_prefix):]\n        bundle = self.object_deserialize(_val)\n        if bundle == '':\n            return self.coerce(bundle, coerce_type=coerce_type, coercer=coercer)\n        else:\n            return bundle\n    if isinstance(val, bytes):\n        val = val.decode()\n    return self.coerce(val, coerce_type=coerce_type, coercer=coercer)"}
{"i": 259, "got": "def itunessd_to_dics(itunessd):\n    \"\"\"pass\"\"\"\n    header_size = get_table_size(header_table)\n    header_chunk = itunessd[0:header_size]\n    header_dic = chunk_to_dic(header_chunk, header_table)\n    tracks_header_dic, tracks_offsets = get_dic_sub_numbers(itunessd, header_dic['tracks_header_offset'], tracks_header_table)\n    tracks_dics = []\n    for track_offset in tracks_offsets:\n        _track_dic = chunk_to_dic(itunessd[track_offset:], track_table)\n        track_dic = get_custom_fields_dic(_track_dic, track_table)\n        tracks_dics.append(track_dic)\n    playlists_header_dic, playlists_offsets = get_dic_sub_numbers(itunessd, header_dic['playlists_header_offset'], playlists_header_table)\n    playlists_dics_and_indexes = []\n    for playlist_offset in playlists_offsets:\n        _playlist_header_dic, indexes_of_tracks = get_dic_sub_numbers(itunessd, playlist_offset, playlist_header_table)\n        playlist_header_dic = get_custom_fields_dic(_playlist_header_dic, playlist_header_table)\n        playlists_dics_and_indexes.append((playlist_header_dic, indexes_of_tracks))\n    return (get_custom_fields_dic(header_dic, header_table), tracks_dics, playlists_dics_and_indexes)"}
{"i": 260, "got": "def dics_to_itunessd(header_dic, tracks_dics, playlists_dics_and_indexes):\n    \"\"\"pass\"\"\"\n    header_dic['length'] = get_table_size(header_table)\n    header_dic['number_of_tracks'] = len(tracks_dics)\n    header_dic['number_of_playlists'] = len(playlists_dics_and_indexes)\n    header_dic['number_of_tracks2'] = 0\n    header_part_size = get_table_size(header_table)\n    tracks_header_dic = {'length': get_table_size(tracks_header_table) + 4 * len(tracks_dics), 'number_of_tracks': len(tracks_dics)}\n    tracks_header_chunk = dic_to_chunk(tracks_header_dic, tracks_header_table)\n    [track_dic.update({'length': get_table_size(track_table)}) for track_dic in tracks_dics]\n    _tracks_chunks = [dic_to_chunk(dic, track_table) for dic in playlists_dics_and_indexes]\n    all_tracks_chunck = b''.join(_tracks_chunks)\n    _length_before_tracks_offsets = header_part_size + len(tracks_header_chunk)\n    tracks_offsets_chunck = get_offsets_chunk(_length_before_tracks_offsets, _tracks_chunks)\n    track_part_chunk = tracks_header_chunk + tracks_offsets_chunck + all_tracks_chunck\n    _playlists_dics = [playlist_indexes[0] for playlist_indexes in playlists_dics_and_indexes]\n    _types = [playlist_dic['type'] for playlist_dic in _playlists_dics]\n    playlists_header_dic = {'length': get_table_size(playlists_header_table) + 4 * len(playlists_dics_and_indexes), 'number_of_all_playlists': len(_types), 'flag1': 4294967295 if _types.count(NORMAL) == 0 else 1, 'number_of_normal_playlists': 4294967295 if _types.count(AUDIOBOOK) == 0 else _types.count(MASTER) + _types.count(NORMAL) + _types.count(PODCAST), 'flag2': 4294967295 if _types.count(AUDIOBOOK) == 0 else _types.count(1) + _types.count(NORMAL), 'number_of_audiobook_playlists': 4294967295 if _types.count(AUDIOBOOK) == 0 else _types.count(PODCAST), 'flag3': 4294967295 if _types.count(AUDIOBOOK) == 0 else _types.count(PODCAST) + _types.count(NORMAL), 'number_of_podcast_playlists': 4294967295 if _types.count(PODCAST) == 0 else _types.count(1) + _types.count(NORMAL)}\n    playlists_header_chunk = dic_to_chunk(playlists_header_dic, playlists_header_table)\n    _playlists_chunks = []\n    for playlist_header_dic, indexes in playlists_dics_and_indexes:\n        dic = playlist_header_dic.copy()\n        dic['length'] = get_table_size(playlist_header_table) + 4 * len(indexes)\n        dic['number_of_all_track'] = len(indexes)\n        dic['number_of_normal_track'] = len(indexes) if dic['type'] in [1, 2] else 0\n        if dic['type'] == MASTER:\n            header_dic['number_of_tracks2'] = len(indexes)\n        _playlist_header_chunk = dic_to_chunk(dic, playlist_header_table)\n        _indexes_chunk = b''.join([i.to_bytes(4, 'little') for i in indexes])\n        playlist_chunk = _playlist_header_chunk + _indexes_chunk\n        _playlists_chunks.append(playlist_chunk)\n    all_playlists_chunk = b''.join(_playlists_chunks)\n    _length_before_playlists_offsets = header_part_size + len(track_part_chunk) + len(playlists_header_chunk)\n    playlists_offsets_chunk = get_offsets_chunk(_length_before_playlists_offsets, _playlists_chunks)\n    playlists_part_chunk = playlists_header_chunk + playlists_offsets_chunk + all_playlists_chunk\n    header_dic['tracks_header_offset'] = header_part_size\n    header_dic['playlists_header_offset'] = header_part_size + len(track_part_chunk)\n    header_part_chunk = dic_to_chunk(header_dic, header_table)\n    itunessd = header_part_chunk + track_part_chunk + playlists_part_chunk\n    return itunessd"}
{"i": 261, "got": "def create_plan(existing_users=None, proposed_users=None, purge_undefined=None, protected_users=None, allow_non_unique_id=True, manage_home=True, manage_keys=True):\n    \"\"\"pass\"\"\"\n    plan = list()\n    proposed_usernames = list()\n    if not purge_undefined:\n        purge_undefined = constants.PURGE_UNDEFINED\n    if not protected_users:\n        protected_users = constants.PROTECTED_USERS\n    if not allow_non_unique_id:\n        allow_non_unique_id = constants.ALLOW_NON_UNIQUE_ID\n    for proposed_user in proposed_users:\n        proposed_usernames.append(proposed_user.name)\n        user_matching_name = existing_users.describe_users(users_filter=dict(name=proposed_user.name))\n        user_matching_id = get_user_by_uid(uid=proposed_user.uid, users=existing_users)\n        if not allow_non_unique_id and user_matching_id and (not user_matching_name):\n            plan.append(dict(action='fail', error='uid_clash', proposed_user=proposed_user, state='existing', result=None))\n        elif not user_matching_name:\n            plan.append(dict(action='add', proposed_user=proposed_user, state='missing', result=None, manage_home=manage_home, manage_keys=manage_keys))\n        else:\n            user_comparison = compare_user(passed_user=proposed_user, user_list=existing_users)\n            if user_comparison.get('result'):\n                plan.append(dict(action='update', proposed_user=proposed_user, state='existing', user_comparison=user_comparison, manage_home=manage_home, manage_keys=manage_keys))\n    if purge_undefined:\n        for existing_user in existing_users:\n            if existing_user.name not in proposed_usernames and existing_user.name not in protected_users:\n                plan.append(dict(action='delete', username=existing_user.name, state='existing', manage_home=manage_home, manage_keys=manage_keys))\n    return plan"}
{"i": 262, "got": "def execute_plan(plan=None):\n    \"\"\"pass\"\"\"\n    execution_result = list()\n    for task in plan:\n        action = task['action']\n        if action == 'delete':\n            command = generate_delete_user_command(username=task.get('username'), manage_home=task['manage_home'])\n            command_output = execute_command(command)\n            execution_result.append(dict(task=task, command_output=command_output))\n            remove_sudoers_entry(username=task.get('username'))\n        elif action == 'add':\n            command = generate_add_user_command(proposed_user=task.get('proposed_user'), manage_home=task['manage_home'])\n            command_output = execute_command(command)\n            if task['proposed_user'].public_keys and task['manage_home'] and task['manage_keys']:\n                write_authorized_keys(task['proposed_user'])\n            if task['proposed_user'].sudoers_entry:\n                write_sudoers_entry(username=task['proposed_user'].name, sudoers_entry=task['proposed_user'].sudoers_entry)\n            execution_result.append(dict(task=task, command_output=command_output))\n        elif action == 'update':\n            result = task['user_comparison'].get('result')\n            action_count = 0\n            for k, _ in iteritems(result):\n                if '_action' in k:\n                    action_count += 1\n            command_output = None\n            if task['manage_home'] and task['manage_keys'] and (action_count == 1) and ('public_keys_action' in result):\n                write_authorized_keys(task['proposed_user'])\n            elif action_count == 1 and 'sudoers_entry_action' in result:\n                write_sudoers_entry(username=task['proposed_user'].name, sudoers_entry=task['user_comparison']['result']['replacement_sudoers_entry'])\n            else:\n                command = generate_modify_user_command(task=task)\n                command_output = execute_command(command)\n                if task['manage_home'] and task['manage_keys'] and result.get('public_keys_action'):\n                    write_authorized_keys(task['proposed_user'])\n                if result.get('sudoers_entry_action'):\n                    write_sudoers_entry(username=task['proposed_user'].name, sudoers_entry=task['user_comparison']['result']['replacement_sudoers_entry'])\n            execution_result.append(dict(task=task, command_output=command_output))"}
{"i": 263, "got": "def output(self, output, accepts, set_http_code, set_content_type):\n    \"\"\"pass\"\"\"\n    graph = Decorator._get_graph(output)\n    if graph is not None:\n        output_mimetype, output_format = self.format_selector.decide(accepts, graph.context_aware)\n        if output_mimetype is None:\n            set_http_code('406 Not Acceptable')\n            return ['406 Not Acceptable'.encode('utf-8')]\n        if 'text' in output_mimetype:\n            output_mimetype = output_mimetype + '; charset=utf-8'\n        serialized = graph.serialize(format=output_format)\n        set_content_type(output_mimetype)\n        return [serialized]\n    else:\n        return output"}
{"i": 264, "got": "def add(self, src):\n    \"\"\"pass\"\"\"\n    checksum = get_checksum(src)\n    filename = self.get_filename(checksum)\n    if not filename:\n        new_name = self._get_new_name()\n        new_realpath = self._storage_dir + '/' + new_name\n        os.makedirs(os.path.split(new_realpath)[0], exist_ok=True)\n        shutil.copyfile(src, new_realpath)\n        self._log[new_name] = {'checksum': checksum, 'mtime': os.path.getmtime(new_realpath), 'size': os.path.getsize(new_realpath)}\n        self.write_log()\n    return checksum"}
{"i": 265, "got": "def schemas(self):\n    \"\"\"pass\"\"\"\n    sql = 'SELECT schema_name FROM information_schema.schemata\\n                 ORDER BY schema_name'\n    schemas = self.query(sql).fetchall()\n    return [s[0] for s in schemas if s[0][:3] != 'pg_']"}
{"i": 266, "got": "def tables(self):\n    \"\"\"pass\"\"\"\n    if self.schema:\n        return self.tables_in_schema(self.schema)\n    else:\n        tables = []\n        for schema in self.schemas:\n            tables = tables + [schema + '.' + t for t in self.tables_in_schema(schema)]\n        return tables"}
{"i": 267, "got": "def _valid_table_name(self, table):\n    \"\"\"pass\"\"\"\n    if table is None or not len(table.strip()):\n        raise ValueError('Invalid table name: %r' % table)\n    return table.strip()"}
{"i": 268, "got": "def build_query(self, sql, lookup):\n    \"\"\"pass\"\"\"\n    for key, val in six.iteritems(lookup):\n        sql = sql.replace('$' + key, val)\n    return sql"}
{"i": 269, "got": "def tables_in_schema(self, schema):\n    \"\"\"pass\"\"\"\n    sql = 'SELECT table_name\\n                 FROM information_schema.tables\\n                 WHERE table_schema = %s'\n    return [t[0] for t in self.query(sql, (schema,)).fetchall()]"}
{"i": 270, "got": "def parse_table_name(self, table):\n    \"\"\"pass\"\"\"\n    if '.' in table:\n        schema, table = table.split('.')\n    else:\n        schema = None\n    return (schema, table)"}
{"i": 271, "got": "def read_authorized_keys(username=None):\n    \"\"\"pass\"\"\"\n    authorized_keys_path = '{0}/.ssh/authorized_keys'.format(os.path.expanduser('~{0}'.format(username)))\n    rnd_chars = random_string(length=RANDOM_FILE_EXT_LENGTH)\n    tmp_authorized_keys_path = '/tmp/authorized_keys_{0}_{1}'.format(username, rnd_chars)\n    authorized_keys = list()\n    copy_result = execute_command(shlex.split(str('{0} cp {1} {2}'.format(sudo_check(), authorized_keys_path, tmp_authorized_keys_path))))\n    result_message = copy_result[0][1].decode('UTF-8')\n    if 'you must have a tty to run sudo' in result_message:\n        raise OSError(\"/etc/sudoers is blocked sudo. Remove entry: 'Defaults    requiretty'.\")\n    if 'No such file or directory' not in result_message:\n        execute_command(shlex.split(str('{0} chmod 755 {1}'.format(sudo_check(), tmp_authorized_keys_path))))\n        with open(tmp_authorized_keys_path) as keys_file:\n            for key in keys_file:\n                authorized_keys.append(PublicKey(raw=key))\n        execute_command(shlex.split(str('{0} rm {1}'.format(sudo_check(), tmp_authorized_keys_path))))\n    return authorized_keys"}
{"i": 272, "got": "def write_authorized_keys(user=None):\n    \"\"\"pass\"\"\"\n    authorized_keys = list()\n    authorized_keys_dir = '{0}/.ssh'.format(os.path.expanduser('~{0}'.format(user.name)))\n    rnd_chars = random_string(length=RANDOM_FILE_EXT_LENGTH)\n    authorized_keys_path = '{0}/authorized_keys'.format(authorized_keys_dir)\n    tmp_authorized_keys_path = '/tmp/authorized_keys_{0}_{1}'.format(user.name, rnd_chars)\n    if not os.path.isdir(authorized_keys_dir):\n        execute_command(shlex.split(str('{0} mkdir -p {1}'.format(sudo_check(), authorized_keys_dir))))\n    for key in user.public_keys:\n        authorized_keys.append('{0}\\n'.format(key.raw))\n    with open(tmp_authorized_keys_path, mode=text_type('w+')) as keys_file:\n        keys_file.writelines(authorized_keys)\n    execute_command(shlex.split(str('{0} cp {1} {2}'.format(sudo_check(), tmp_authorized_keys_path, authorized_keys_path))))\n    execute_command(shlex.split(str('{0} chown -R {1} {2}'.format(sudo_check(), user.name, authorized_keys_dir))))\n    execute_command(shlex.split(str('{0} chmod 700 {1}'.format(sudo_check(), authorized_keys_dir))))\n    execute_command(shlex.split(str('{0} chmod 600 {1}'.format(sudo_check(), authorized_keys_path))))\n    execute_command(shlex.split(str('{0} rm {1}'.format(sudo_check(), tmp_authorized_keys_path))))"}
{"i": 273, "got": "def b64encoded(self):\n    \"\"\"pass\"\"\"\n    if self._b64encoded:\n        return text_type(self._b64encoded).strip('\\r\\n')\n    else:\n        return base64encode(self.raw)"}
{"i": 274, "got": "def raw(self):\n    \"\"\"pass\"\"\"\n    if self._raw:\n        return text_type(self._raw).strip('\\r\\n')\n    else:\n        return text_type(base64decode(self._b64encoded)).strip('\\r\\n')"}
{"i": 275, "got": "def add_format(mimetype, format, requires_context=False):\n    \"\"\"pass\"\"\"\n    global formats, ctxless_mimetypes, all_mimetypes\n    formats[mimetype] = format\n    if not requires_context:\n        ctxless_mimetypes.append(mimetype)\n    all_mimetypes.append(mimetype)"}
{"i": 276, "got": "def add_format(self, mimetype, format, requires_context=False):\n    \"\"\"pass\"\"\"\n    self.formats[mimetype] = format\n    if not requires_context:\n        self.ctxless_mimetypes.append(mimetype)\n    self.all_mimetypes.append(mimetype)"}
{"i": 277, "got": "def get_default_mimetype(self):\n    \"\"\"pass\"\"\"\n    mimetype = self.default_mimetype\n    if mimetype is None:\n        mimetype = DEFAULT_MIMETYPE\n    if mimetype is None:\n        mimetype = 'application/rdf+xml'\n    return mimetype"}
{"i": 278, "got": "def send_http(session, method, url, *, retries=1, interval=1, backoff=2, http_status_codes_to_retry=HTTP_STATUS_CODES_TO_RETRY, fn=lambda x: x, **kwargs):\n    \"\"\"pass\"\"\"\n    backoff_interval = interval\n    raised_exc = None\n    attempt = 0\n    if method not in ['get', 'patch', 'post']:\n        raise ValueError\n    if retries == -1:\n        attempt = -1\n    elif retries == 0:\n        attempt = 1\n    else:\n        attempt = retries + 1\n    while attempt != 0:\n        if raised_exc:\n            logger.error('Caught \"%s\" url:%s method:%s, remaining tries %s, sleeping %.2fsecs', raised_exc, method.upper(), url, attempt, backoff_interval)\n            await asyncio.sleep(backoff_interval)\n            backoff_interval *= backoff\n        try:\n            response = (await getattr(session, method)(url, **kwargs))[0]\n            if response.status == 200:\n                return await fn(response)\n            elif response.status in http_status_codes_to_retry:\n                logger.error('Received invalid response code:%s error:%s response:%s url:%s', response.status, '', response.reason, url)\n                raise aiohttp.ClientResponseError(code=response.status, message=response.reason, request_info=response.request_info, history=response.history)\n            else:\n                raise FailedRequest(code=response.status, message='Non-retryable response code', raised='aiohttp.ClientResponseError', url=url)\n        except aiohttp.ClientError as exc:\n            try:\n                code = exc.code\n            except AttributeError:\n                code = ''\n            raised_exc = FailedRequest(code=code, message='%s.%s' % (exc.__class__.__module__, exc.__class__.__qualname__), raised=url)\n        except asyncio.TimeoutError as exc:\n            raised_exc = FailedRequest(code='', message='asyncio.TimeoutError', raised=exc.__class__.__module__ + '.' + exc.__class__.__qualname__, url=url)\n        attempt -= 1\n    if raised_exc:\n        raise raised_exc"}
{"i": 279, "got": "def generate_output(self, writer):\n    \"\"\"pass\"\"\"\n    with codecs_open(os.path.join(os.path.dirname(__file__), 'sitemap-stylesheet.xsl'), 'r', encoding='utf-8') as fd_origin:\n        with codecs_open(os.path.join(self.path_output, 'sitemap-stylesheet.xsl'), 'w', encoding='utf-8') as fd_destination:\n            xsl = fd_origin.read()\n            xsl = xsl.replace('{{ SITENAME }}', self.context.get('SITENAME'))\n            fd_destination.write(xsl)\n    urls = ''\n    articles_sorted = sorted(self.context['articles'], key=self.__get_date_key, reverse=True)\n    pages_with_date = list(filter(lambda p: getattr(p, 'modified', False) or getattr(p, 'date', False), self.context.get('pages')))\n    pages_with_date_sorted = sorted(pages_with_date, key=self.__get_date_key, reverse=True)\n    pages_without_date = list(filter(lambda p: p != 'index', self.context.get('pages')))\n    pages_without_date_sorted = sorted(pages_without_date, key=self.__get_title_key, reverse=False)\n    pages_sorted = pages_with_date_sorted + pages_without_date_sorted\n    if 'index' in self.context.get('DIRECT_TEMPLATES'):\n        index_reference = None\n        if len(articles_sorted) > 0:\n            index_reference = articles_sorted[0]\n        elif len(pages_sorted) > 0:\n            index_reference = pages_sorted[0]\n        if index_reference is not None:\n            urls += self.__create_url_node_for_content(index_reference, 'index', url=self.url_site)\n    for article in articles_sorted:\n        urls += self.__create_url_node_for_content(article, 'articles', url=urljoin(self.url_site, article.url))\n    for page in pages_sorted:\n        urls += self.__create_url_node_for_content(page, 'pages', url=urljoin(self.url_site, page.url))\n    if self.context.get('CATEGORY_URL'):\n        urls += self.__process_url_wrapper_elements(self.context.get('categories'))\n    if self.context.get('TAG_URL'):\n        urls += self.__process_url_wrapper_elements(sorted(self.context.get('tags'), key=lambda x: x[0]))\n    if self.context.get('AUTHOR_URL'):\n        urls += self.__process_url_wrapper_elements(self.context.get('authors'))\n    for direct_template in list(filter(lambda p: getattr(p, 'modified', None) is not getattr(p, 'date', None), self.context.get('DIRECT_TEMPLATES'))):\n        modification_time = getattr(articles_sorted[0], 'modified', getattr(articles_sorted[0], 'date', None))\n        url = self.__get_direct_template_url(direct_template)\n        urls += self.__create_url_node_for_content(None, 'others', url, modification_time)\n    with codecs_open(os.path.join(self.path_output, 'sitemap.xml'), 'w', encoding='utf-8') as fd:\n        fd.write(self.xml_wrap % {'SITEURL': self.url_site, 'urls': urls})"}
{"i": 280, "got": "def __get_direct_template_url(self, name):\n    \"\"\"pass\"\"\"\n    url = self.pelican_settings.get('{}_SAVE_AS'.format(name.upper()))\n    if url is None:\n        url = self.settings.get('{}_URL'.format(name.upper()), '{}.html'.format(name))\n    return urljoin(self.url_site, url)"}
{"i": 281, "got": "def __process_url_wrapper_elements(self, elements):\n    \"\"\"pass\"\"\"\n    urls = ''\n    for url_wrapper, articles in elements:\n        urls += self.__create_url_node_for_content(url=url_wrapper, modification_time='others', url=urljoin(self.url_site, url_wrapper.url), modification_time=self.__get_date_key(sorted(articles, key=self.__get_date_key, reverse=True)[0]))\n    return urls"}
{"i": 282, "got": "def __create_url_node_for_content(self, content, content_type, url=None, modification_time=None):\n    \"\"\"pass\"\"\"\n    loc = url\n    if loc is None:\n        loc = urljoin(self.url_site, self.context.get('ARTICLE_URL').format(**content.url_format))\n    lastmod = None\n    if modification_time is not None:\n        lastmod = modification_time.strftime('%Y-%m-%d')\n    elif content is not None and getattr(content, 'modified', None) is not None:\n        lastmod = getattr(content, 'modified').strftime('%Y-%m-%d')\n    elif content is not None and getattr(content, 'date', None) is not None:\n        lastmod = getattr(content, 'date').strftime('%Y-%m-%d')\n    output = '<loc>{}</loc>'.format(loc)\n    if lastmod is not None:\n        output += '\\n<lastmod>{}</lastmod>'.format(lastmod)\n    output += '\\n<changefreq>{}</changefreq>'.format(self.settings.get('changefrequencies').get(content_type))\n    output += '\\n<priority>{:.2f}</priority>'.format(self.settings.get('priorities').get(content_type))\n    return self.template_url.format(output)"}
{"i": 283, "got": "def add_attachment(message, attachment, rfc2231=True):\n    \"\"\"pass\"\"\"\n    data = attachment.read()\n    part = MIMEBase('application', 'octet-stream')\n    part.set_payload(data)\n    encoders.encode_base64(part)\n    filename = attachment.name if rfc2231 else Header(attachment.name).encode()\n    part.add_header('Content-Disposition', 'attachment', filename=filename)\n    message.attach(part)"}
{"i": 284, "got": "def _login(self):\n    \"\"\"pass\"\"\"\n    server, port, mode, debug = self.connection_details\n    if mode == 'SSL':\n        smtp_class = smtplib.SMTP_SSL\n    else:\n        smtp_class = smtplib.SMTP\n    smtp = smtp_class(server, port)\n    smtp.set_debuglevel(debug)\n    if mode == 'TLS':\n        smtp.starttls()\n    self.authenticate(smtp)\n    return smtp"}
{"i": 285, "got": "def send(self, email, attachments=()):\n    \"\"\"pass\"\"\"\n    msg = email.as_mime(attachments)\n    if 'From' not in msg:\n        msg['From'] = self.sender_address()\n    if self._conn:\n        self._conn.sendmail(self.username, email.recipients, msg.as_string())\n    else:\n        with self:\n            self._conn.sendmail(self.username, email.recipients, msg.as_string())"}
{"i": 286, "got": "def check(qpi_or_h5file, checks=['attributes', 'background']):\n    \"\"\"pass\"\"\"\n    if isinstance(checks, str):\n        checks = [checks]\n    for ch in checks:\n        if not ch in ['attributes', 'background']:\n            raise ValueError('Unknown check: {}'.format(check))\n    if isinstance(qpi_or_h5file, QPImage):\n        qpi = qpi_or_h5file\n    else:\n        qpi = QPImage(h5file=qpi_or_h5file, h5mode='r')\n    if 'attributes' in checks:\n        check_attributes(qpi)\n    if 'background' in checks:\n        check_background(qpi)"}
{"i": 287, "got": "def check_attributes(qpi):\n    \"\"\"pass\"\"\"\n    missing_attrs = []\n    for key in DATA_KEYS:\n        if key not in qpi.meta:\n            missing_attrs.append(key)\n    if missing_attrs:\n        msg = 'Attributes are missing: {} '.format(missing_attrs) + 'in {}!'.format(qpi)\n        raise IntegrityCheckError(msg)"}
{"i": 288, "got": "def check_background(qpi):\n    \"\"\"pass\"\"\"\n    for imdat in [qpi._amp, qpi._pha]:\n        try:\n            fit, attrs = imdat.get_bg(key='fit', ret_attrs=True)\n        except KeyError:\n            pass\n        else:\n            kwargs = dict(attrs)\n            binkey = 'estimate_bg_from_mask'\n            if binkey in imdat.h5:\n                kwargs['from_mask'] = imdat.h5[binkey][:]\n            else:\n                kwargs['from_mask'] = None\n            with h5py.File('check.h5', driver='core', backing_store=False) as h5:\n                testimdat = imdat.__class__(h5)\n                testimdat['raw'] = imdat.raw\n                try:\n                    bg = imdat.get_bg('data')\n                except KeyError:\n                    pass\n                else:\n                    testimdat.set_bg(bg, key='data')\n                testimdat.estimate_bg(**kwargs)\n                if not np.allclose(testimdat.get_bg(key='fit'), fit):\n                    msg = 'Wrong estimated (fitted) background!'\n                    raise IntegrityCheckError(msg)"}
{"i": 289, "got": "def write_image_dataset(group, key, data, h5dtype=None):\n    \"\"\"pass\"\"\"\n    if h5dtype is None:\n        h5dtype = data.dtype\n    if key in group:\n        del group[key]\n    if group.file.driver == 'core':\n        kwargs = {}\n    else:\n        kwargs = {'fletcher32': True, 'chunks': data.shape}\n        kwargs.update(COMPRESSION)\n    dset = group.create_dataset(key, data=data.astype(h5dtype), **kwargs)\n    dset.attrs.create('CLASS', b'IMAGE')\n    dset.attrs.create('IMAGE_VERSION', b'1.2')\n    dset.attrs.create('IMAGE_SUBCLASS', b'IMAGE_GRAYSCALE')\n    return dset"}
{"i": 290, "got": "def info(self):\n    \"\"\"pass\"\"\"\n    info = []\n    name = self.__class__.__name__.lower()\n    for key in VALID_BG_KEYS:\n        if key in self.h5['bg_data']:\n            attrs = self.h5['bg_data'][key].attrs\n            for akey in attrs:\n                atr = attrs[akey]\n                var = '{} background {}'.format(name, akey)\n                info.append((var, atr))\n    if 'fit' in self.h5['bg_data']:\n        var_mask = '{} background from mask'.format(name)\n        if 'estimate_bg_from_mask' in self.h5 and self.h5['estimate_bg_from_mask'] is not None:\n            info.append((var_mask, True))\n        elif 'estimate_bg_from_binary' in self.h5 and self.h5['estimate_bg_from_binary'] is not None:\n            warnings.warn('Old file format detected!', DeprecationWarning)\n            info.append((var_mask, True))\n        else:\n            info.append((var_mask, False))\n    return info"}
{"i": 291, "got": "def del_bg(self, key):\n    \"\"\"pass\"\"\"\n    if key not in VALID_BG_KEYS:\n        raise ValueError('Invalid bg key: {}'.format(key))\n    elif key in self.h5['bg_data']:\n        del self.h5['bg_data'][key]\n    else:\n        msg = \"No bg data to clear for '{}' in {}.\".format(key, self)\n        warnings.warn(msg)"}
{"i": 292, "got": "def main() -> int:\n    \"\"\"pass\"\"\"\n    parser = argparse.ArgumentParser()\n    parser.add_argument('--overwrite', help='Overwrites the unformatted source files with the well-formatted code in place. If not set, an exception is raised if any of the files do not conform to the style guide.', action='store_true')\n    args = parser.parse_args()\n    overwrite = bool(args.overwrite)\n    repo_root = pathlib.Path(__file__).parent\n    print(\"YAPF'ing...\")\n    if overwrite:\n        subprocess.check_call(['yapf', '--in-place', '--style=style.yapf', '--recursive', 'tests', 'icontract', 'setup.py', 'precommit.py'], cwd=repo_root.as_posix())\n    else:\n        subprocess.check_call(['yapf', '--diff', '--style=style.yapf', '--recursive', 'tests', 'icontract', 'setup.py', 'precommit.py'], cwd=repo_root.as_posix())\n    print(\"Mypy'ing...\")\n    subprocess.check_call(['mypy', 'icontract', 'tests'], cwd=repo_root.as_posix())\n    print(\"Pylint'ing...\")\n    subprocess.check_call(['pylint', '--rcfile=pylint.rc', 'tests', 'icontract'], cwd=repo_root.as_posix())\n    print(\"Pydocstyle'ing...\")\n    subprocess.check_call(['pydocstyle', 'icontract'], cwd=repo_root.as_posix())\n    print('Testing...')\n    env = os.environ.copy()\n    env['ICONTRACT_SLOW'] = 'true'\n    subprocess.check_call(['coverage', 'run', '--source', 'icontract', '-m', 'unittest', 'discover', 'tests'], cwd=repo_root.as_posix(), env=env)\n    subprocess.check_call(['coverage', 'report'])\n    print('Doctesting...')\n    subprocess.check_call(['python3', '-m', 'doctest', 'README.rst'])\n    for pth in (repo_root / 'icontract').glob('**/*.py'):\n        subprocess.check_call(['python3', '-m', 'doctest', pth.as_posix()])\n    print('Checking the restructured text of the readme...')\n    subprocess.check_call(['python3', 'setup.py', 'check', '--restructuredtext', '--strict'])\n    return 0"}
{"i": 293, "got": "def _collapse_invariants(bases: List[type], namespace: MutableMapping[str, Any]) -> None:\n    \"\"\"pass\"\"\"\n    invariants = []\n    for base in bases:\n        if hasattr(base, '__invariants__'):\n            invariants.extend(getattr(base, '__invariants__'))\n    if '__invariants__' in namespace:\n        invariants.extend(namespace['__invariants__'])\n    if invariants:\n        namespace['__invariants__'] = invariants"}
{"i": 294, "got": "def _collapse_preconditions(base_preconditions: List[List[Contract]], bases_have_func: bool, preconditions: List[List[Contract]], func: Callable[..., Any]) -> List[List[Contract]]:\n    \"\"\"pass\"\"\"\n    if not base_preconditions and bases_have_func and preconditions:\n        raise TypeError(\"The function {} can not weaken the preconditions because the bases specify no preconditions at all. Hence this function must accept all possible input since the preconditions are OR'ed and no precondition implies a dummy precondition which is always fulfilled.\".format(func.__qualname__))\n    return base_preconditions + preconditions"}
{"i": 295, "got": "def _collapse_snapshots(base_snapshots: List[Snapshot], snapshots: List[Snapshot]) -> List[Snapshot]:\n    \"\"\"pass\"\"\"\n    seen_names = set()\n    collapsed = base_snapshots + snapshots\n    for snap in collapsed:\n        if snap.name in seen_names:\n            raise ValueError('There are conflicting snapshots with the name: {!r}.\\n\\nPlease mind that the snapshots are inherited from the base classes. Does one of the base classes defines a snapshot with the same name?'.format(snap.name))\n        seen_names.add(snap.name)\n    return collapsed"}
{"i": 296, "got": "def _collapse_postconditions(base_postconditions: List[Contract], postconditions: List[Contract]) -> List[Contract]:\n    \"\"\"pass\"\"\"\n    return base_postconditions + postconditions"}
{"i": 297, "got": "def _decorate_namespace_function(bases: List[type], namespace: MutableMapping[str, Any], key: str) -> None:\n    \"\"\"pass\"\"\"\n    value = namespace[key]\n    assert inspect.isfunction(value) or isinstance(value, (staticmethod, classmethod))\n    if inspect.isfunction(value):\n        func = value\n    elif isinstance(value, (staticmethod, classmethod)):\n        func = value.__func__\n    else:\n        raise NotImplementedError('Unexpected value for a function: {}'.format(value))\n    preconditions: List[icontract._checkers.Precondition] = []\n    snapshots: List[icontract._checkers.Snapshot] = []\n    postconditions: List[icontract._checkers.Postcondition] = []\n    contract_checker = icontract._checkers.find_checker(func=func)\n    if contract_checker is not None:\n        preconditions = contract_checker.__preconditions__\n        snapshots = contract_checker.__postcondition_snapshots__\n        postconditions = contract_checker.__postconditions__\n    if key not in ['__init__']:\n        base_preconditions: List[icontract._checkers.Precondition] = []\n        base_snapshots: List[icontract._checkers.Snapshot] = []\n        base_postconditions: List[icontract._checkers.Postcondition] = []\n        bases_have_func = False\n        for base in bases:\n            if not hasattr(base, key):\n                continue\n            bases_have_func = True\n            base_func = getattr(base, key)\n            base_contract_checker = icontract._checkers.find_checker(func=base_func)\n            if base_contract_checker is None:\n                continue\n            base_preconditions.extend(base_contract_checker.__preconditions__)\n            base_snapshots.extend(base_contract_checker.__postcondition_snapshots__)\n            base_postconditions.extend(base_contract_checker.__postconditions__)\n        preconditions = _collapse_preconditions(base_preconditions=base_preconditions, bases_have_func=bases_have_func, preconditions=preconditions, func=func)\n        snapshots = _collapse_snapshots(base_snapshots=base_snapshots, snapshots=snapshots)\n        postconditions = _collapse_postconditions(base_postconditions=base_postconditions, postconditions=postconditions)\n    if preconditions or postconditions:\n        if contract_checker is None:\n            contract_checker = icontract._checkers.decorate_with_checker(func=func)\n            if inspect.isfunction(value):\n                namespace[key] = contract_checker\n            elif isinstance(value, staticmethod):\n                namespace[key] = staticmethod(contract_checker)\n            elif isinstance(value, classmethod):\n                namespace[key] = classmethod(contract_checker)\n            else:\n                raise NotImplementedError('Unexpected value for a function: {}'.format(value))\n        contract_checker.__preconditions__ = preconditions\n        contract_checker.__postcondition_snapshots__ = snapshots\n        contract_checker.__postconditions__ = postconditions"}
{"i": 298, "got": "def tokenize_sents(string):\n    \"\"\"pass\"\"\"\n    string = six.text_type(string)\n    spans = []\n    for match in re.finditer('[^\\\\s]+', string):\n        spans.append(match)\n    spans_count = len(spans)\n    rez = []\n    off = 0\n    for i in range(spans_count):\n        tok = string[spans[i].start():spans[i].end()]\n        if i == spans_count - 1:\n            rez.append(string[off:spans[i].end()])\n        elif tok[-1] in ['.', '!', '?', '\u2026', '\u00bb']:\n            tok1 = tok[re.search('[.!?\u2026\u00bb]', tok).start() - 1]\n            next_tok = string[spans[i + 1].start():spans[i + 1].end()]\n            if next_tok[0].isupper():\n                continue\n            elif tok1.isupper():\n                continue\n            elif tok[-1] != '.':\n                continue\n            elif tok1[0] == '(':\n                continue\n            elif tok in ABBRS:\n                continue\n            else:\n                rez.append(string[off:spans[i].end()])\n                off = spans[i + 1].start()\n    return rez"}
{"i": 299, "got": "def tokenize_text(string):\n    \"\"\"pass\"\"\"\n    string = six.text_type(string)\n    rez = []\n    for part in string.split('\\n'):\n        par = []\n        for sent in tokenize_sents(part):\n            par.append(tokenize_words(sent))\n        if par:\n            rez.append(par)\n    return rez"}
{"i": 300, "got": "def override_djconfig(**new_cache_values):\n    \"\"\"pass\"\"\"\n\n    def decorator(func):\n\n        @wraps(func)\n        def func_wrapper(*args, **kw):\n            old_cache_values = {key: getattr(conf.config, key) for key in new_cache_values}\n            conf.config._set_many(new_cache_values)\n            try:\n                return func(*args, **kw)\n            finally:\n                conf.config._set_many(old_cache_values)\n        return func_wrapper\n    return decorator"}
{"i": 301, "got": "def serialize(value, field):\n    \"\"\"pass\"\"\"\n    assert isinstance(field, forms.Field)\n    if isinstance(field, forms.ModelMultipleChoiceField):\n        return json.dumps([v.pk for v in value])\n    elif isinstance(value, models.Model):\n        return value.pk\n    else:\n        return value"}
{"i": 302, "got": "def get_version(package):\n    \"\"\"pass\"\"\"\n    with io.open(os.path.join(BASE_DIR, package, '__init__.py'), encoding='utf-8') as fh:\n        return [l.split('=', 1)[1].strip().strip(\"'\").strip('\"') for l in fh.readlines() if '__version__' in l][0]"}
{"i": 303, "got": "def _check_backend():\n    \"\"\"pass\"\"\"\n    middleware = set(getattr(settings, 'MIDDLEWARE', None) or getattr(settings, 'MIDDLEWARE_CLASSES', None) or [])\n    if 'djconfig.middleware.DjConfigLocMemMiddleware' in middleware:\n        return\n    elif 'djconfig.middleware.DjConfigMiddleware' in middleware:\n        return\n    else:\n        raise ValueError('djconfig.middleware.DjConfigMiddleware is required but it was not found in MIDDLEWARE_CLASSES nor in MIDDLEWARE')"}
{"i": 304, "got": "def _register(self, form_class, check_middleware=True):\n    \"\"\"pass\"\"\"\n    if not issubclass(form_class, _ConfigFormBase):\n        raise ValueError('The form does not inherit from `forms.ConfigForm`')\n    self._registry.add(form_class)\n    if check_middleware:\n        _check_backend()"}
{"i": 305, "got": "def _reload(self):\n    \"\"\"pass\"\"\"\n    ConfigModel = apps.get_model('djconfig.Config')\n    cache = {}\n    data = dict(ConfigModel.objects.all().values_list('key', 'value'))\n    for form_class in self._registry:\n        empty_form = form_class()\n        cache.update({name: field.initial for name, field in empty_form.fields.items()})\n        form = form_class(data={name: _deserialize(data[name], field) for name, field in empty_form.fields.items() if name in data and (not isinstance(field, forms.FileField))})\n        form.is_valid()\n        cache.update({name: _unlazify(value) for name, value in form.cleaned_data.items() if name in data})\n        cache.update({name: data[name] for name, field in empty_form.fields.items() if name in data and isinstance(field, forms.FileField)})\n    cache['_updated_at'] = data.get('_updated_at')\n    self._cache = cache"}
{"i": 306, "got": "def Mixed(*types):\n    \"\"\"pass\"\"\"\n    if len(types) < 2:\n        raise ValueError('Mixed type requires at least 2 specific types')\n    types = set(types)\n\n    class MixedType(type):\n\n        def __instancecheck__(cls, instance):\n            \"\"\"pass\"\"\"\n            for mtype in types:\n                if isinstance(instance, mtype):\n                    return True\n            return False\n\n    class Mixed(object):\n        __metaclass__ = MixedType\n    return Mixed"}
{"i": 307, "got": "def one_of(*args):\n    \"\"\"pass\"\"\"\n    if len(args) == 1 and isinstance(args[0], list):\n        items = args[0]\n    else:\n        items = list(args)\n\n    def validate(value):\n        if value not in items:\n            return e('{} is not in the list {}', value, items)\n    return validate"}
{"i": 308, "got": "def gte(min_value):\n    \"\"\"pass\"\"\"\n\n    def validate(value):\n        if value < min_value:\n            return e('{} is not greater than or equal to {}', value, min_value)\n    return validate"}
{"i": 309, "got": "def lte(max_value):\n    \"\"\"pass\"\"\"\n\n    def validate(value):\n        if value > max_value:\n            return e('{} is not less than or equal to {}', value, max_value)\n    return validate"}
{"i": 310, "got": "def gt(gt_value):\n    \"\"\"pass\"\"\"\n\n    def validate(value):\n        if value <= gt_value:\n            return e('{} is not greater than {}', value, gt_value)\n    return validate"}
{"i": 311, "got": "def lt(lt_value):\n    \"\"\"pass\"\"\"\n\n    def validate(value):\n        if value >= lt_value:\n            return e('{} is not less than {}', value, lt_value)\n    return validate"}
{"i": 312, "got": "def load_config(path=None, defaults=None):\n    \"\"\"pass\"\"\"\n    if defaults is None:\n        defaults = DEFAULT_FILES\n    config = ConfigParser(allow_no_value=True)\n    if defaults:\n        config.read(defaults)\n    if path:\n        with open(path) as fh:\n            config.read_file(fh)\n    return config"}
{"i": 313, "got": "def as_dict(config):\n    \"\"\"pass\"\"\"\n    settings = defaultdict(lambda: {})\n    for section in config.sections():\n        for key, val in config.items(section):\n            settings[section][key] = val\n    return settings"}
{"i": 314, "got": "def initialize(self, timeouts):\n    \"\"\"pass\"\"\"\n    if self.bind is True:\n        self.socket.bind(self.address)\n    else:\n        self.socket.connect(self.address)\n    self._set_timeouts(timeouts)"}
{"i": 315, "got": "def _set_timeouts(self, timeouts):\n    \"\"\"pass\"\"\"\n    send_timeout, recv_timeout = (None, None)\n    try:\n        send_timeout, recv_timeout = timeouts\n    except TypeError:\n        raise EndpointError('`timeouts` must be a pair of numbers (2, 3) which represent the timeout values for send and receive respectively')\n    if send_timeout is not None:\n        self.socket.set_int_option(nanomsg.SOL_SOCKET, nanomsg.SNDTIMEO, send_timeout)\n    if recv_timeout is not None:\n        self.socket.set_int_option(nanomsg.SOL_SOCKET, nanomsg.RCVTIMEO, recv_timeout)"}
{"i": 316, "got": "def send(self, payload):\n    \"\"\"pass\"\"\"\n    payload = self.encode(payload)\n    payload = self.sign(payload)\n    self.socket.send(payload)"}
{"i": 317, "got": "def receive(self, decode=True):\n    \"\"\"pass\"\"\"\n    payload = self.socket.recv()\n    payload = self.verify(payload)\n    if decode:\n        payload = self.decode(payload)\n    return payload"}
{"i": 318, "got": "def sign(self, payload):\n    \"\"\"pass\"\"\"\n    if self.authenticator:\n        return self.authenticator.signed(payload)\n    else:\n        return payload"}
{"i": 319, "got": "def verify(self, payload):\n    \"\"\"pass\"\"\"\n    if not self.authenticator:\n        return payload\n    try:\n        self.authenticator.auth(payload)\n        return self.authenticator.unsigned(payload)\n    except AuthenticatorInvalidSignature:\n        raise\n    except Exception as exception:\n        raise AuthenticateError(str(exception))"}
{"i": 320, "got": "def get_summary(list_all=[], **kwargs):\n    \"\"\"pass\"\"\"\n    all_summary = []\n    for module in list_all:\n        summary = {'module_name': module['Name'], 'show_all': kwargs.get('show_all', True), 'project_name': kwargs.get('proj_name', 'TestProject'), 'home_page': kwargs.get('home_page', __about__.HOME_PAGE), 'start_time': '', 'end_time': '', 'duration_seconds': 0, 'total_case_num': 0, 'pass_cases_num': 0, 'fail_cases_num': 0, 'details': []}\n        for case in module['TestCases']:\n            case_detail = {}\n            case_detail['linkurl'] = './caselogs/%s_%s.log' % (case['case_name'], case['exec_date'])\n            if case['status'].lower() == 'pass':\n                summary['pass_cases_num'] += 1\n                case_detail['c_style'] = 'tr_pass'\n            else:\n                summary['fail_cases_num'] += 1\n                case_detail['c_style'] = 'tr_fail'\n            case_detail.update(case)\n            summary['details'].append(case_detail)\n        try:\n            st = module['TestCases'][0].get('start_at')\n            et = module['TestCases'][-1].get('end_at')\n            summary['start_time'] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(st))\n            summary['end_time'] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(et))\n            summary['duration_seconds'] = float('%.2f' % (et - st))\n        except Exception as _:\n            logger.log_warning(\"Will set 'start_at' and 'end_at' to 'None'\")\n            summary['start_time'], summary['end_time'], summary['duration_seconds'] = (None, None, None)\n        if summary['fail_cases_num'] > 0:\n            summary['dict_report'] = {'result': 0, 'message': 'failure', 'pass': summary['pass_cases_num'], 'fail': summary['fail_cases_num']}\n        else:\n            summary['dict_report'] = {'result': 1, 'message': 'success', 'pass': summary['pass_cases_num'], 'fail': summary['fail_cases_num']}\n        all_summary.append(summary)\n    return all_summary"}
{"i": 321, "got": "def add_report_data(list_all, module_name='TestModule', **kwargs):\n    \"\"\"pass\"\"\"\n    start_at = kwargs.get('start_at')\n    case_name = kwargs.get('case_name', 'TestCase')\n    raw_case_name = kwargs.get('raw_case_name', 'TestCase')\n    exec_date_time = time.localtime(start_at)\n    execdate = time.strftime('%Y-%m-%d', exec_date_time)\n    exectime = time.strftime('%H:%M:%S', exec_date_time)\n    _case_report = {'resp_tester': kwargs.get('resp_tester', 'administrator'), 'tester': kwargs.get('tester', 'administrator'), 'case_name': case_name, 'raw_case_name': raw_case_name, 'status': kwargs.get('status', 'Pass'), 'exec_date': execdate, 'exec_time': exectime, 'start_at': start_at, 'end_at': kwargs.get('end_at')}\n    for module in list_all:\n        if module_name != module['Name']:\n            continue\n        for case in module['TestCases']:\n            if raw_case_name == case['raw_case_name']:\n                case.update(_case_report)\n                return list_all\n        else:\n            module['TestCases'].append(_case_report)\n            return list_all\n    list_all.append({'Name': module_name, 'TestCases': [_case_report]})\n    return list_all"}
{"i": 322, "got": "def get_webpack(request, name='DEFAULT'):\n    \"\"\"pass\"\"\"\n    if not hasattr(request, '_webpack_map'):\n        request._webpack_map = {}\n    wp = request._webpack_map.get(name)\n    if wp is None:\n        wp = request._webpack_map[name] = Webpack(request, name)\n    return wp"}
{"i": 323, "got": "def includeme(config):\n    \"\"\"pass\"\"\"\n    settings = config.registry.settings\n    root_package_name = config.root_package.__name__\n    config.registry.webpack = {'DEFAULT': WebpackState(settings, root_package_name)}\n    for extra_config in aslist(settings.get('webpack.configs', [])):\n        state = WebpackState(settings, root_package_name, name=extra_config)\n        config.registry.webpack[extra_config] = state\n    for state in six.itervalues(config.registry.webpack):\n        if state.static_view:\n            config.add_static_view(name=state.static_view_name, path=state.static_view_path, cache_max_age=state.cache_max_age)\n    config.add_request_method(get_webpack, 'webpack')"}
{"i": 324, "got": "def _get_setting(self, setting, default=None, name=None, inherit=True):\n    \"\"\"pass\"\"\"\n    if name is None:\n        name = self.name\n    if name == 'DEFAULT':\n        return self._settings.get('webpack.{0}'.format(setting), default)\n    val = self._settings.get('webpack.{0}.{1}'.format(name, setting), SENTINEL)\n    if val is SENTINEL:\n        if inherit:\n            return self._get_setting(setting, default, 'DEFAULT')\n        else:\n            return default\n    return val"}
{"i": 325, "got": "def load_stats(self, cache=None, wait=None):\n    \"\"\"pass\"\"\"\n    if cache is None:\n        cache = not self.debug\n    if wait is None:\n        wait = self.debug\n    while not cache or self._stats is None:\n        self._stats = self._load_stats()\n        start = time.time()\n        while wait and self._stats.get('status') == 'compiling':\n            if self.timeout and time.time() - start > self.timeout:\n                raise RuntimeError('Webpack {0!r} timed out while compiling'.format(self.stats_file.path))\n            time.sleep(0.1)\n    return self._stats"}
{"i": 326, "got": "def _load_stats(self):\n    \"\"\"pass\"\"\"\n    for attempt in range(0, 3):\n        try:\n            with self.stats_file.open() as f:\n                return json.load(f)\n        except ValueError:\n            if attempt < 2:\n                time.sleep(attempt * 0.2)\n            else:\n                raise\n        except IOError:\n            raise IOError('Could not read stats file {0}. Make sure you are using the webpack-bundle-tracker plugin'.format(self.stats_file))"}
{"i": 327, "got": "def _chunk_filter(self, extensions):\n    \"\"\"pass\"\"\"\n    if isinstance(extensions, six.string_types):\n        extensions = extensions.split()\n\n    def _filter(chunk):\n        \"\"\"pass\"\"\"\n        name = chunk['name']\n        if extensions is not None and (not any((name.endswith(e) for e in extensions))):\n            return False\n        for pattern in self.state.ignore_re:\n            if pattern.match(name):\n                return False\n        for pattern in self.state.ignore:\n            if fnmatch.fnmatchcase(name, pattern):\n                return False\n        return True\n    return _filter"}
{"i": 328, "got": "def _unique_names():\n    \"\"\"pass\"\"\"\n    characters = 'abcdefghijklmnopqrstuvwxyz0123456789'\n    characters = [characters[i:i + 1] for i in irange(len(characters))]\n    rng = random.Random()\n    while True:\n        letters = [rng.choice(characters) for i in irange(10)]\n        yield ''.join(letters)"}
{"i": 329, "got": "def escape_queue(s):\n    \"\"\"pass\"\"\"\n    if isinstance(s, PosixPath):\n        s = unicode_(s)\n    elif isinstance(s, bytes):\n        s = s.decode('utf-8')\n    if s.startswith('~/'):\n        return '~/' + shell_escape(s[2:])\n    else:\n        return shell_escape(s)"}
{"i": 330, "got": "def parse_ssh_destination(destination):\n    \"\"\"pass\"\"\"\n    match = _re_ssh.match(destination)\n    if not match:\n        raise InvalidDestination('Invalid destination: %s' % destination)\n    user, password, host, port = match.groups()\n    info = {}\n    if user:\n        info['username'] = user\n    else:\n        info['username'] = getpass.getuser()\n    if password:\n        info['password'] = password\n    if port:\n        info['port'] = int(port)\n    info['hostname'] = host\n    return info"}
{"i": 331, "got": "def _ssh_client(self):\n    \"\"\"pass\"\"\"\n    ssh = paramiko.SSHClient()\n    ssh.load_system_host_keys()\n    ssh.set_missing_host_key_policy(paramiko.RejectPolicy())\n    return ssh"}
{"i": 332, "got": "def _connect(self):\n    \"\"\"pass\"\"\"\n    ssh = self._ssh_client()\n    logger.debug('Connecting with %s', ', '.join(('%s=%r' % (k, v if k != 'password' else '***') for k, v in iteritems(self.destination))))\n    ssh.connect(**self.destination)\n    logger.debug('Connected to %s', self.destination['hostname'])\n    self._ssh = ssh"}
{"i": 333, "got": "def get_client(self):\n    \"\"\"pass\"\"\"\n    if self._ssh is None:\n        self._connect()\n        return self._ssh\n    else:\n        try:\n            chan = self._ssh.get_transport().open_session()\n        except (socket.error, paramiko.SSHException):\n            logger.warning('Lost connection, reconnecting...')\n            self._ssh.close()\n            self._connect()\n        finally:\n            chan.close()\n        return self._ssh"}
{"i": 334, "got": "def activate(lancet, method, project):\n    \"\"\"pass\"\"\"\n    with taskstatus('Looking up project') as ts:\n        if method == 'key':\n            func = get_project_keys\n        elif method == 'dir':\n            func = get_project_keys\n        for key, project_path in func(lancet):\n            if key.lower() == project.lower():\n                break\n        else:\n            ts.abort('Project \"{}\" not found (using {}-based lookup)', project, method)\n    config = load_config(os.path.join(project_path, LOCAL_CONFIG))\n    lancet.defer_to_shell('cd', project_path)\n    venv = config.get('lancet', 'virtualenv', fallback=None)\n    if venv:\n        venv_path = os.path.join(project_path, os.path.expanduser(venv))\n        activate_script = os.path.join(venv_path, 'bin', 'activate')\n        lancet.defer_to_shell('source', activate_script)\n    elif 'VIRTUAL_ENV' in os.environ:\n        lancet.defer_to_shell('deactivate')"}
{"i": 335, "got": "def workon(ctx, issue_id, new, base_branch):\n    \"\"\"pass\"\"\"\n    lancet = ctx.obj\n    if not (issue_id or new):\n        raise click.UsageError('Provide either an issue ID or the --new flag.')\n    elif issue_id and new:\n        raise click.UsageError('Provide either an issue ID or the --new flag, but not both.')\n    summary = click.prompt('Issue summary')\n    issue = create_issue(lancet, summary=summary, add_to_active_sprint=True)\n    else:\n        issue = get_issue(lancet, issue_id)\n    username = lancet.tracker.whoami()\n    active_status = lancet.config.get('tracker', 'active_status')\n    if not base_branch:\n        base_branch = lancet.config.get('repository', 'base_branch')\n    branch = get_branch(lancet, issue, base_branch)\n    transition = get_transition(ctx, lancet, issue, active_status)\n    assign_issue(lancet, issue, username, active_status)\n    set_issue_status(lancet, issue, active_status, transition)\n    with taskstatus('Checking out working branch') as ts:\n        lancet.repo.checkout(branch.name)\n        ts.ok('Checked out working branch based on \"{}\"'.format(base_branch))\n    with taskstatus('Starting harvest timer') as ts:\n        lancet.timer.start(issue)\n        ts.ok('Started harvest timer')"}
{"i": 336, "got": "def time(lancet, issue):\n    \"\"\"pass\"\"\"\n    issue = get_issue(lancet, issue)\n    with taskstatus('Starting harvest timer') as ts:\n        lancet.timer.start(issue)\n        ts.ok('Started harvest timer')"}
{"i": 337, "got": "def pause(ctx):\n    \"\"\"pass\"\"\"\n    lancet = ctx.obj\n    paused_status = lancet.config.get('tracker', 'paused_status')\n    issue = get_issue(lancet)\n    transition = get_transition(ctx, lancet, issue, paused_status)\n    set_issue_status(lancet, issue, paused_status, transition)\n    with taskstatus('Pausing harvest timer') as ts:\n        lancet.timer.pause()\n        ts.ok('Harvest timer paused')"}
{"i": 338, "got": "def raisefrom(exc_type, message, exc):\n    \"\"\"pass\"\"\"\n    if sys.version_info[:2] >= (3, 2):\n        six.raise_from(exc_type(message), exc)\n    else:\n        six.reraise(exc_type, '%s - %s' % (message, exc), sys.exc_info()[2])"}
{"i": 339, "got": "def init_runner(self, parser, tracers, projinfo):\n    \"\"\"pass\"\"\"\n    self.parser = parser\n    self.tracers = tracers\n    self.proj_info = projinfo"}
{"i": 340, "got": "def _run_grid_multiprocess(self, func, iterables):\n    \"\"\"pass\"\"\"\n    multiprocessing.freeze_support()\n    pool = multiprocessing.Pool()\n    pool_tracers = pool.map(func, iterables)\n    pool.close()\n    pool.join()\n    self.tracers = dict(zip(self._default_devices, pool_tracers))"}
{"i": 341, "got": "def _run_grid_multithread(self, func, iterables):\n    \"\"\"pass\"\"\"\n    f = lambda x: threading.Thread(target=func, args=(x,))\n    threads = map(f, iterables)\n    for thread in threads:\n        thread.setDaemon(True)\n        thread.start()\n        thread.join()"}
{"i": 342, "got": "def init_project_env(subject='Automation', proj_path=None, sysencoding='utf-8', debug=False):\n    \"\"\"pass\"\"\"\n    if not proj_path:\n        try:\n            executable_file_path = os.path.dirname(os.path.abspath(inspect.stack()[-1][1]))\n        except:\n            executable_file_path = os.path.dirname(sys.path[0])\n        proj_path = executable_file_path\n    p = os.path.join(proj_path, subject)\n    proj_conf = {'sys_coding': sysencoding, 'debug': debug, 'module_name': os.path.splitext(os.path.basename(subject))[0], 'cfg_file': os.path.join(p, 'config.ini'), 'path': {'root': p, 'case': os.path.join(p, 'testcase'), 'data': os.path.join(p, 'data'), 'buffer': os.path.join(p, 'buffer'), 'resource': os.path.join(p, 'resource'), 'tools': os.path.join(p, 'tools'), 'rst': os.path.join(p, 'result'), 'rst_log': os.path.join(p, 'result', 'testcase'), 'rst_shot': os.path.join(p, 'result', 'screenshots')}}\n    [FileSystemUtils.mkdirs(v) for v in proj_conf['path'].values()]\n    if os.path.isdir(p):\n        sys.path.append(p)\n    else:\n        ''\n    return proj_conf"}
{"i": 343, "got": "def get_long_description():\n    \"\"\"pass\"\"\"\n    here = os.path.abspath(os.path.dirname(__file__))\n    with copen(os.path.join(here, 'DESCRIPTION.rst'), encoding='utf-8') as description:\n        return description.read()"}
{"i": 344, "got": "def flatten(nested_list: list) -> list:\n    \"\"\"pass\"\"\"\n    return list(sorted(filter(lambda y: y is not None, list(map(lambda x: nested_list.extend(x) if isinstance(x, list) else x, nested_list)))))"}
{"i": 345, "got": "def get_py_files(dir_name: str) -> list:\n    \"\"\"pass\"\"\"\n    return flatten([['{0}/{1}'.format(path, f) for f in files if f.endswith('.py')] for path, _, files in os.walk(dir_name) if not path.startswith('./build')])"}
{"i": 346, "got": "def exit(self) -> None:\n    \"\"\"pass\"\"\"\n    total = sum((len(logs) for logs in self.logs.values()))\n    if self.json:\n        self.logs['total'] = total\n        print(json.dumps(self.logs, indent=self.indent))\n    else:\n        for name, log in self.logs.items():\n            if not log or self.parser[name].as_bool('quiet'):\n                continue\n            print('[[{0}]]'.format(name))\n            getattr(snekchek.format, name + '_format')(log)\n            print('\\n')\n        print('-' * 30)\n        print('Total:', total)\n    sys.exit(self.status_code)"}
{"i": 347, "got": "def run_linter(self, linter) -> None:\n    \"\"\"pass\"\"\"\n    self.current = linter.name\n    if linter.name not in self.parser['all'].as_list('linters') or linter.base_pyversion > sys.version_info:\n        return\n    if any((x not in self.installed for x in linter.requires_install)):\n        raise ModuleNotInstalled(linter.requires_install)\n    linter.add_output_hook(self.out_func)\n    linter.set_config(self.fn, self.parser[linter.name])\n    linter.run(self.files)\n    self.status_code = self.status_code or linter.status_code"}
{"i": 348, "got": "def read_rcfile():\n    \"\"\"pass\"\"\"\n    files = ['{}/.millipederc'.format(os.environ.get('HOME')), '/usr/local/etc/millipederc', '/etc/millipederc']\n    for filepath in files:\n        if os.path.isfile(filepath):\n            with open(filepath) as rcfile:\n                return parse_rcfile(rcfile)\n    return {}"}
{"i": 349, "got": "def parse_rcfile(rcfile):\n    \"\"\"pass\"\"\"\n\n    def parse_bool(value):\n        \"\"\"pass\"\"\"\n        value = value.lower()\n        if value in ('yes', 'true'):\n            return True\n        elif value in ('no', 'false'):\n            return False\n        else:\n            raise ValueError(\"Can't parse {}\".format(value))\n    valid_keys = {'size': int, 'comment': str, 'template': str, 'reverse': parse_bool, 'opposite': parse_bool, 'position': int}\n    params = {}\n    for linenum, line in enumerate(rcfile):\n        line = line.strip()\n        if not line or line[0] == '#':\n            continue\n        pos = line.find(' ')\n        key = line[:pos]\n        value = line[pos:].strip()\n        if key in valid_keys.keys():\n            try:\n                params[key] = valid_keys[key](value)\n            except ValueError:\n                print('Ignoring line {} from rcfile'.format(linenum + 1), file=sys.stderr)\n    return params"}
{"i": 350, "got": "def compute_settings(args, rc_settings):\n    \"\"\"pass\"\"\"\n    settings = {}\n    for key, value in args.items():\n        if key in ['reverse', 'opposite']:\n            settings[key] = value ^ rc_settings.get(key, False)\n        else:\n            settings[key] = value or rc_settings.get(key)\n    if not settings['size']:\n        settings['size'] = DEFAULT_SIZE\n    return settings"}
{"i": 351, "got": "def millipede(size, comment=None, reverse=False, template='default', position=0, opposite=False):\n    \"\"\"pass\"\"\"\n    padding_offsets = [2, 1, 0, 1, 2, 3, 4, 4, 3]\n    padding_suite_length = len(padding_offsets)\n    head_padding_extra_offset = 2\n    if opposite:\n        padding_offsets.reverse()\n    position = position or 0\n    templates = {'frozen': '\u2554\u2550(\u2744\u2744\u2744)\u2550\u2557', 'love': '\u255a\u2550(\u2744\u2744\u2744)\u2550\u255d', 'corporate': '\u2554\u2299 \u2299\u2557', 'musician': '\u255a\u2299 \u2299\u255d', 'bocal': {'bodyr': '\u2554\u2550(\u2665\u2665\u2665)\u2550\u2557', 'body': '\u255a\u2550(\u2665\u2665\u2665)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'ascii': {'bodyr': '\u2554\u2550(\u00a9\u00a9\u00a9)\u2550\u2557', 'body': '\u255a\u2550(\u00a9\u00a9\u00a9)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'default': {'bodyr': '\u2554\u2550(\u266b\u2669\u266c)\u2550\u2557', 'body': '\u255a\u2550(\u266b\u2669\u266c)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'inception': {'bodyr': '\u2554\u2550(\ud83d\udc1f\ud83d\udc1f\ud83d\udc1f)\u2550\u2557', 'body': '\u255a\u2550(\ud83d\udc1f\ud83d\udc1f\ud83d\udc1f)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'humancentipede': '|=(###)=|', 'heart': {'bodyr': '/\u2299 \u2299\\\\', 'body': '\\\\\u2299 \u2299/', 'headr': '\u2554\u2550(\u2588\u2588\u2588)\u2550\u2557', 'head': '\u255a\u2550(\u2588\u2588\u2588)\u2550\u255d'}, 'corporate': {'bodyr': '\u2554\u2550(\ud83d\udc1b\ud83d\udc1b\ud83d\udc1b)\u2550\u2557', 'body': '\u255a\u2550(\ud83d\udc1b\ud83d\udc1b\ud83d\udc1b)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'musician': {'bodyr': '\u2554\u2550(\ud83d\ude37\ud83d\ude37\ud83d\ude37)\u2550\u2557', 'body': '\u255a\u2550(\ud83d\ude37\ud83d\ude37\ud83d\ude37)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}, 'bocal': {'bodyr': '\u2554\u2550(\u2764\ufe0f\u2764\ufe0f\u2764\ufe0f)\u2550\u2557', 'body': '\u255a\u2550(\u2764\ufe0f\u2764\ufe0f\u2764\ufe0f)\u2550\u255d', 'headr': '\u2554\u2299 \u2299\u2557', 'head': '\u255a\u2299 \u2299\u255d'}}\n    template = templates.get(template, templates['default'])\n    head = '{}{}\\n'.format(' ' * (padding_offsets[position % padding_suite_length] + head_padding_extra_offset), template['headr'] if reverse else template['head'])\n    body_lines = ['{}{}\\n'.format(' ' * (padding_offsets[x + position] % padding_suite_length), template['bodyr'] if reverse else template['body']) for x in range(size)]\n    if reverse:\n        body_lines.reverse()\n    body = ''.join(body_lines)\n    output = ''\n    if reverse:\n        output += body + head\n        if comment:\n            output += '\\n' + comment + '\\n'\n    elif comment:\n        output += comment + '\\n\\n'\n    output += head + body\n    return output"}
{"i": 352, "got": "def api_post(message, url, name, http_data=None, auth=None):\n    \"\"\"pass\"\"\"\n    try:\n        import requests\n    except ImportError:\n        print('requests is required to do api post.', file=sys.stderr)\n        sys.exit(1)\n    data = {name: message}\n    if http_data:\n        for var in http_data:\n            key, value = var.split('=')\n            data[key] = value\n    response = requests.post(url, data=data, auth=auth)\n    if response.status_code != 200:\n        raise RuntimeError('Unable to post data')"}
{"i": 353, "got": "def run_main(args: argparse.Namespace, do_exit=True) -> None:\n    \"\"\"pass\"\"\"\n    if args.init:\n        generate()\n        return\n    handler = CheckHandler(file=args.config_file, out_json=args.json, files=args.files)\n    for style in get_stylers():\n        handler.run_linter(style())\n    for linter in get_linters():\n        handler.run_linter(linter())\n    for security in get_security():\n        handler.run_linter(security())\n    for tool in get_tools():\n        tool = tool()\n        if tool.name == 'pypi' and handler.status_code != 0:\n            continue\n        handler.run_linter(tool)\n    if do_exit:\n        handler.exit()\n    return handler.status_code"}
{"i": 354, "got": "def main() -> None:\n    \"\"\"pass\"\"\"\n    parser = argparse.ArgumentParser()\n    parser.add_argument('--json', help='output in JSON format', action='store_true', default=False)\n    parser.add_argument('--config-file', help='Select config file to use', default='.snekrc')\n    parser.add_argument('files', metavar='file', nargs='*', default=[], help='Files to run checks against')\n    parser.add_argument('--init', help='generate snekrc', action='store_true', default=False)\n    args = parser.parse_args()\n    run_main(args)"}
{"i": 355, "got": "def get_session(user_agent=None, user_agent_config_yaml=None, user_agent_lookup=None, **kwargs):\n    \"\"\"pass\"\"\"\n    s = requests.Session()\n    ua = kwargs.get('full_agent')\n    if not ua:\n        ua = UserAgent.get(user_agent, user_agent_config_yaml, user_agent_lookup, **kwargs)\n    s.headers['User-Agent'] = ua\n    extra_params = os.getenv('EXTRA_PARAMS')\n    if extra_params is not None:\n        extra_params_dict = dict()\n        if '=' in extra_params:\n            logger.info('Loading extra parameters from environment variable')\n            for extra_param in extra_params.split(','):\n                key, value = extra_param.split('=')\n                extra_params_dict[key] = value\n    else:\n        extra_params_found = False\n        extra_params_dict = kwargs.get('extra_params_dict')\n        if extra_params_dict:\n            extra_params_found = True\n            logger.info('Loading extra parameters from dictionary')\n        extra_params_json = kwargs.get('extra_params_json', '')\n        if extra_params_json:\n            if extra_params_found:\n                raise SessionError('More than one set of extra parameters given!')\n            extra_params_found = True\n            logger.info('Loading extra parameters from: %s' % extra_params_json)\n            extra_params_dict = load_json(extra_params_json)\n        extra_params_yaml = kwargs.get('extra_params_yaml', '')\n        if extra_params_found:\n            if extra_params_yaml:\n                raise SessionError('More than one set of extra parameters given!')\n        else:\n            if extra_params_yaml:\n                logger.info('Loading extra parameters from: %s' % extra_params_yaml)\n                extra_params_dict = load_yaml(extra_params_yaml)\n            else:\n                extra_params_dict = dict()\n        extra_params_lookup = kwargs.get('extra_params_lookup')\n        if extra_params_lookup:\n            extra_params_dict = extra_params_dict.get(extra_params_lookup)\n            if extra_params_dict is None:\n                raise SessionError('%s does not exist in extra_params!' % extra_params_lookup)\n    auth_found = False\n    basic_auth = os.getenv('BASIC_AUTH')\n    if basic_auth:\n        logger.info('Loading authorisation from basic_auth environment variable')\n        auth_found = True\n    else:\n        basic_auth = kwargs.get('basic_auth')\n        if basic_auth:\n            logger.info('Loading authorisation from basic_auth argument')\n            auth_found = True\n    bauth = extra_params_dict.get('basic_auth')\n    if bauth:\n        if not auth_found:\n            basic_auth = bauth\n            logger.info('Loading authorisation from basic_auth parameter')\n            auth_found = True\n        del extra_params_dict['basic_auth']\n    s.params = extra_params_dict\n    auth = kwargs.get('auth')\n    if auth:\n        if auth_found:\n            raise SessionError('More than one authorisation given!')\n        logger.info('Loading authorisation from auth argument')\n        auth_found = True\n    basic_auth_file = kwargs.get('basic_auth_file')\n    if basic_auth_file:\n        if auth_found:\n            raise SessionError('More than one authorisation given!')\n        logger.info('Loading authorisation from: %s' % basic_auth_file)\n        basic_auth = load_file_to_str(basic_auth_file)\n    if basic_auth:\n        auth = decode(basic_auth)\n    s.auth = auth\n    status_forcelist = kwargs.get('status_forcelist', [429, 500, 502, 503, 504])\n    method_whitelist = kwargs.get('method_whitelist', frozenset(['HEAD', 'TRACE', 'GET', 'PUT', 'OPTIONS', 'DELETE']))\n    retries = Retry(total=5, backoff_factor=0.4, status_forcelist=status_forcelist, method_whitelist=method_whitelist, raise_on_redirect=True, raise_on_status=True)\n    s.mount('http://', HTTPAdapter(retries, max_retries=100, pool_connections=100))\n    s.mount('https://', HTTPAdapter(retries, max_retries=100, pool_connections=100))\n    return s"}
{"i": 356, "got": "def connect(self):\n    \"\"\"pass\"\"\"\n    if self.connection_type.lower() == 'ssl':\n        self.server = smtplib.SMTP_SSL(host=self.host, port=self.port, local_hostname=self.local_hostname, timeout=self.timeout, source_address=self.source_address)\n    elif self.connection_type.lower() == 'lmtp':\n        self.server = smtplib.LMTP(host=self.host, port=self.port, local_hostname=self.local_hostname, source_address=self.source_address)\n    else:\n        self.server = smtplib.SMTP(host=self.host, port=self.port, local_hostname=self.local_hostname, timeout=self.timeout, source_address=self.source_address)\n    self.server.login(self.username, self.password)"}
{"i": 357, "got": "def send(self, recipients, subject, text_body, html_body=None, sender=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if sender is None:\n        sender = self.sender\n    v = validate_email(sender, check_deliverability=False)\n    sender = v['email']\n    normalised_recipients = list()\n    for recipient in recipients:\n        v = validate_email(recipient, check_deliverability=True)\n        normalised_recipients.append(v['email'])\n    if html_body is not None:\n        msg = MIMEMultipart('alternative')\n        part1 = MIMEText(text_body, 'plain')\n        part2 = MIMEText(html_body, 'html')\n        msg.attach(part1)\n        msg.attach(part2)\n    else:\n        msg = MIMEText(text_body)\n    msg['Subject'] = subject\n    msg['From'] = sender\n    msg['To'] = ', '.join(normalised_recipients)\n    self.connect()\n    self.server.sendmail(sender, normalised_recipients, msg.as_string(), **kwargs)\n    self.close()"}
{"i": 358, "got": "def get_session(db_url):\n    \"\"\"pass\"\"\"\n    engine = create_engine(db_url, poolclass=NullPool, echo=False)\n    Session = sessionmaker(bind=engine)\n    Base.metadata.create_all(engine)\n    return Session()"}
{"i": 359, "got": "def get_params_from_sqlalchemy_url(db_url):\n    \"\"\"pass\"\"\"\n    result = urlsplit(db_url)\n    return {'database': result.path[1:], 'host': result.hostname, 'port': result.port, 'username': result.username, 'password': result.password, 'driver': result.scheme}"}
{"i": 360, "got": "def get_unset_cache(self):\n    \"\"\"pass\"\"\"\n    caches = []\n    if self._cached_api_global_response is None:\n        caches.append('global')\n    if self._cached_api_ticker_response is None:\n        caches.append('ticker')\n    return (len(caches), caches)"}
{"i": 361, "got": "def dicts_filter(dicts_object, field_to_filter, value_of_filter):\n    \"\"\"pass\"\"\"\n    lambda_query = lambda value: value[field_to_filter] == value_of_filter\n    filtered_coin = filter(lambda_query, dicts_object)\n    selected_coins = list(filtered_coin)\n    return selected_coins"}
{"i": 362, "got": "def send_request(self, endpoint='ticker', coin_name=None, **kwargs):\n    \"\"\"pass\"\"\"\n    built_url = self._make_url(endpoint, coin_name)\n    payload = dict(**kwargs)\n    self._process_request(endpoint, built_url, payload)"}
{"i": 363, "got": "def get_response(self, data_type=None):\n    \"\"\"pass\"\"\"\n    if not data_type:\n        return self.cache.get_response(r_type='ticker') or self.cache.get_response(r_type='global')\n    elif data_type == 'ticker':\n        return self.cache.get_response(r_type='ticker')\n    else:\n        return self.cache.get_response(r_type='global')"}
{"i": 364, "got": "def iso_639_alpha3(code):\n    \"\"\"pass\"\"\"\n    code = normalize_code(code)\n    code = ISO3_MAP.get(code, code)\n    if code in ISO3_ALL:\n        return code\n    else:\n        return None"}
{"i": 365, "got": "def list_to_alpha3(languages, synonyms=True):\n    \"\"\"pass\"\"\"\n    codes = set([])\n    for language in ensure_list(languages):\n        code = iso_639_alpha3(language)\n        if code is not None:\n            codes.add(code)\n            if synonyms:\n                codes.update(expand_synonyms(code))\n    return codes"}
{"i": 366, "got": "def _search_generator(self, item: Any, reverse: bool=False) -> Generator[Any, None, None]:\n    \"\"\"pass\"\"\"\n    results = 0\n    for _, x in self.enumerate(item, reverse=reverse):\n        yield x\n        results += 1\n    if results == 0:\n        raise SearchError(str(item))"}
{"i": 367, "got": "def _search_generator(self, item: Any) -> Generator[Any, None, None]:\n    \"\"\"pass\"\"\"\n    results = 0\n    for x in self.enumerate(item):\n        yield x\n        results += 1\n    if results == 0:\n        raise SearchError(str(item))"}
{"i": 368, "got": "def _search_generator(self, item: Any) -> Generator[Tuple[Any, Any], None, None]:\n    \"\"\"pass\"\"\"\n    results = 0\n    for key, value in self.enumerate(item):\n        yield (key, value)\n        results += 1\n    if results == 0:\n        raise SearchError(str(item))"}
{"i": 369, "got": "def serialize(obj):\n    \"\"\"pass\"\"\"\n    from datetime import datetime, date, time\n    if isinstance(obj, date) and (not isinstance(obj, datetime)):\n        obj = datetime.combine(obj, time.min)\n    if isinstance(obj, datetime):\n        return obj.isoformat()"}
{"i": 370, "got": "def check(response, expected_status=200, url=None):\n    \"\"\"pass\"\"\"\n    if response.status_code != expected_status:\n        if url is None:\n            url = response.url\n        try:\n            err = response.json()\n        except:\n            err = {}\n        if all((x in err for x in ('status', 'message', 'description', 'details'))):\n            raise _APIError(err['status'], err['message'], url, err, err['description'], err['details'])\n        suffix = '.html' if '<html' in response.text else '.txt'\n        msg = response.text\n        if len(msg) > 200:\n            with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as f:\n                f.write(response.text.encode('utf-8'))\n            msg = '{}...\\n\\n[snipped; full response written to {f.name}'.format(*msg[:100], **locals())\n        msg = 'Request {url!r} returned code {response.status_code}, expected {expected_status}. \\n{msg}'.format(**locals())\n        raise _APIError(response.status_code, msg, url, response.text)\n    if response.headers.get('Content-Type') == 'application/json':\n        try:\n            return response.json()\n        except:\n            raise Exception('Cannot decode json; text={response.text!r}'.format(**locals()))\n    else:\n        return response.text"}
{"i": 371, "got": "def _get_auth(self, user=None, password=None):\n    \"\"\"pass\"\"\"\n    fn = os.path.expanduser(AUTH_FILE)\n    if os.path.exists(fn):\n        for i, line in enumerate(csv.reader(open(fn))):\n            if len(line) != 3:\n                log.warning('Cannot parse line {i} in {fn}'.format(**locals()))\n                continue\n            hostname, username, pwd = line\n            if hostname in ('', '*', self.host) and (user is None or username == user):\n                return (username, pwd)\n    if user is None:\n        user = os.environ.get('AMCAT_USER', os.environ.get('USER'))\n    if password is None:\n        password = os.environ.get('AMCAT_PASSWORD')\n    if user is None or password is None:\n        raise Exception('No authentication info for {user}@{self.host} from {fn} or AMCAT_USER / AMCAT_PASSWORD variables'.format(**locals()))\n    return (user, password)"}
{"i": 372, "got": "def request(self, url, method='get', format=None, data=None, expected_status=None, headers=None, use_xpost=True, **options):\n    \"\"\"pass\"\"\"\n    if expected_status is None:\n        if method == 'get':\n            expected_status = 200\n        elif method == 'post':\n            expected_status = 201\n        else:\n            raise ValueError('No expected status supplied and method unknown.')\n    if not url.startswith('http'):\n        url = '{self.host}/api/v4/{url}'.format(**locals())\n    if format is not None:\n        options = dict({'format': format}, **options)\n    options = {field: value for field, value in options.items() if value is not None}\n    headers = dict(headers or {}, Authorization='Token {}'.format(self.token))\n    if method == 'get' and use_xpost:\n        assert data is None\n        headers.update({'X-HTTP-METHOD-OVERRIDE': method})\n        data = options\n        options = None\n        method = 'post'\n    r = requests.request(method, url, data=data, params=options, headers=headers)\n    log.debug('HTTP {method} {url} (options={options!r}, data={data!r},headers={headers}) -> {r.status_code}'.format(**locals()))\n    return check(r, expected_status=expected_status)"}
{"i": 373, "got": "def get_pages(self, url, page=1, page_size=100, yield_pages=False, **filters):\n    \"\"\"pass\"\"\"\n    n = 0\n    for page in itertools.count(page):\n        r = self.request(url, page=page, page_size=page_size, **filters)\n        n += len(r['results'])\n        log.debug('Got {url} page {page} / {pages}'.format(url=url, **r))\n        if yield_pages:\n            yield r\n        else:\n            for row in r['results']:\n                yield row\n        if r['next'] is None:\n            break"}
{"i": 374, "got": "def get_scroll(self, url, page_size=100, yield_pages=False, **filters):\n    \"\"\"pass\"\"\"\n    n = 0\n    options = dict(page_size=page_size, **filters)\n    format = filters.get('format')\n    while True:\n        r = self.request(url, use_xpost=False, **options)\n        n += len(r['results'])\n        log.debug('Got {} {n}/{total}'.format((url.split('?')[0],), total=r['total'], **locals()))\n        if yield_pages:\n            yield r\n        else:\n            for row in r['results']:\n                yield row\n        if r['next'] is None:\n            break\n        url = r['next']\n        options = {'format': None}"}
{"i": 375, "got": "def get_error(self, block=True, timeout=None):\n    \"\"\"pass\"\"\"\n    return self._error_queue.get(block=block, timeout=timeout)"}
{"i": 376, "got": "def get_feedback(self, block=True, timeout=None):\n    \"\"\"pass\"\"\"\n    if self._feedback_greenlet is None:\n        self._feedback_greenlet = gevent.spawn(self._feedback_loop)\n    return self._feedback_queue.get(block=block, timeout=timeout)"}
{"i": 377, "got": "def wait_send(self, timeout=None):\n    \"\"\"pass\"\"\"\n    self._send_queue_cleared.clear()\n    self._send_queue_cleared.wait(timeout=timeout)"}
{"i": 378, "got": "def start(self):\n    \"\"\"pass\"\"\"\n    if self._send_greenlet is None:\n        self._send_greenlet = gevent.spawn(self._send_loop)"}
{"i": 379, "got": "def stop(self, timeout=10.0):\n    \"\"\"pass\"\"\"\n    if self._send_greenlet is not None and self._send_queue.qsize() > 0:\n        self.wait_send(timeout=timeout)\n    if self._send_greenlet is not None:\n        gevent.kill(self._send_greenlet)\n        self._send_greenlet = None\n    if self._error_greenlet is not None:\n        gevent.kill(self._error_greenlet)\n        self._error_greenlet = None\n    if self._feedback_greenlet is not None:\n        gevent.kill(self._feedback_greenlet)\n        self._feedback_greenlet = None\n    return self._send_queue.qsize() < 1"}
{"i": 380, "got": "def convert_to_ssml(text, text_format):\n    \"\"\"pass\"\"\"\n    if text_format is None:\n        return text\n    elif text_format == 'plain':\n        return plain_to_ssml(text)\n    elif text_format == 'html':\n        return html_to_ssml(text)\n    else:\n        raise ValueError(text_format + ': text format not found.')"}
{"i": 381, "got": "def html_to_ssml(text):\n    \"\"\"pass\"\"\"\n    ssml_text = reduce(lambda x, y: x.replace(y, html_to_ssml_maps[y]), html_to_ssml_maps, text)\n    return ssml_text"}
{"i": 382, "got": "def iexpand(string, keep_escapes=False):\n    \"\"\"pass\"\"\"\n    if isinstance(string, bytes):\n        is_bytes = True\n        string = string.decode('latin-1')\n    else:\n        is_bytes = False\n    if is_bytes:\n        return (entry.encode('latin-1') for entry in ExpandBrace(keep_escapes).expand(string))\n    else:\n        return (entry for entry in ExpandBrace(keep_escapes).expand(string))"}
{"i": 383, "got": "def set_expanding(self):\n    \"\"\"pass\"\"\"\n    status = not self.expanding\n    if status:\n        self.expanding = True\n    return status"}
{"i": 384, "got": "def get_escape(self, c, i):\n    \"\"\"pass\"\"\"\n    try:\n        escaped = next(i)\n    except StopIteration:\n        escaped = ''\n    if self.keep_escapes:\n        return c + escaped\n    else:\n        return escaped"}
{"i": 385, "got": "def squash(self, a, b):\n    \"\"\"pass\"\"\"\n    return (u''.join(x) if isinstance(x, tuple) else x for x in itertools.product(a, b))"}
{"i": 386, "got": "def get_literals(self, c, i, depth):\n    \"\"\"pass\"\"\"\n    result = ['']\n    is_dollar = False\n    while c:\n        ignore_brace = is_dollar\n        is_dollar = False\n        if c == '$':\n            is_dollar = True\n        elif c == '\\\\':\n            c = [self.get_escape(c, i)]\n        else:\n            if not ignore_brace and c == '{':\n                index = i.index\n                try:\n                    seq = self.get_sequence(next(i), i, depth + 1)\n                    if seq:\n                        c = seq\n                except StopIteration:\n                    i.rewind(i.index - index)\n                if not is_dollar and self.is_expanding() and (c in [',', '}']):\n                    i.rewind(1)\n                    return ((x for x in result),)\n            else:\n                result = self.squash(result, [c] if isinstance(c, str) else c)\n                c = next(i)\n    return ((x for x in result),)"}
{"i": 387, "got": "def combine(self, a, b):\n    \"\"\"pass\"\"\"\n    for l in [a, b]:\n        for x in l:\n            yield x"}
{"i": 388, "got": "def add_episode(self, text, text_format, title=None, author=None, summary='watson', publish_date=None, synthesizer='. ', synth_args=None, sentence_break=' '):\n    \"\"\"pass\"\"\"\n    if title in self.episodes:\n        raise ValueError('\"' + title + '\" already exists as an episode title.')\n    link = self.output_path + '/' + title.replace(' ', '_').lower() + '.mp3'\n    episode_text = convert_to_ssml(text, text_format)\n    new_episode = Episode(episode_text, text_format, title, author, link, summary, publish_date, synthesizer, synth_args, sentence_break)\n    self.episodes[title] = new_episode"}
{"i": 389, "got": "def add_scheduled_job(self, text_source, cron_args, text_format, title=None, author='watson', summary=None, synthesizer='. ', synth_args=None, sentence_break=' '):\n    \"\"\"pass\"\"\"\n    if not callable(text_source):\n        raise TypeError('Argument \"text\" must be a function')\n\n    def add_episode():\n        episode_text = text_source()\n        episode_title = title + '_' + datetime.utcnow().strftime('%Y%m%d%H%M%S')\n        self.add_episode(episode_text, text_format, episode_title, author, summary, datetime.utcnow(), synthesizer, synth_args, sentence_break)\n    self._scheduler.add_job(add_episode, 'cron', id=title, **cron_args)[self.scheduled_jobs[title]]\n    if not self._scheduler.running:\n        self._scheduler.start()"}
{"i": 390, "got": "def publish(self, titles):\n    \"\"\"pass\"\"\"\n    if isinstance(titles, Sequence) and (not isinstance(titles, six.string_types)):\n        for title in titles:\n            self.episodes[title].publish()\n    elif isinstance(titles, six.string_types):\n        self.episodes[titles].publish()\n    else:\n        raise TypeError('titles must be a string or a sequence of strings.')\n    self.update_rss_feed()"}
{"i": 391, "got": "def render_audio(self):\n    \"\"\"pass\"\"\"\n    segment = text_to_speech(self._text, self.synthesizer, self.synth_args, self.sentence_break)\n    milli = len(segment)\n    seconds = '{0:.1f}'.format(float(milli) / 1000 % 60).zfill(2)\n    minutes = '{0:.0f}'.format(milli / 60000 % 60).zfill(2)\n    hours = '{0:.0f}'.format(milli / (3600 * 1000) % 24).zfill(2)\n    self.duration = hours + ':' + minutes + ':' + seconds\n    segment.export(self.link, format='mp3')\n    self.length = os.path.getsize(self.link)"}
{"i": 392, "got": "def remove_exponent(d):\n    \"\"\"pass\"\"\"\n    if d == d.to_integral():\n        return d.quantize(Decimal(1))\n    else:\n        return d.normalize()"}
{"i": 393, "got": "def millify(n, precision=0, drop_nulls=True, prefixes=[]):\n    \"\"\"pass\"\"\"\n    millnames = ['', 'k', 'M', 'B', 'T', 'P', 'E', 'Z', 'Y']\n    if prefixes:\n        millnames = ['']\n        millnames.extend(prefixes)\n    n = float(n)\n    millidx = max(0, min(len(millnames) - 1, int(math.floor(0 if n == 0 else math.log10(abs(n)) / 3))))\n    result = '{:.{precision}f}'.format(n / 10 ** (3 * millidx), precision=precision)\n    if drop_nulls:\n        result = remove_exponent(Decimal(result))\n    return '{0}{dx}'.format(result, dx=millnames[millidx])"}
{"i": 394, "got": "def prettify(amount, separator=','):\n    \"\"\"pass\"\"\"\n    orig = str(amount)\n    new = re.sub('^(-?\\\\d+)(\\\\d{3})', '\\\\g<1>{0}\\\\g<2>'.format(separator), str(amount))\n    if orig == new:\n        return new\n    else:\n        return prettify(new)"}
{"i": 395, "got": "def load_json(json_data, decoder=None):\n    \"\"\"pass\"\"\"\n    if decoder is None:\n        decoder = DateTimeDecoder\n    return json.loads(json_data, object_hook=decoder.decode)"}
{"i": 396, "got": "def load_json_file(file, decoder=None):\n    \"\"\"pass\"\"\"\n    if decoder is None:\n        decoder = DateTimeDecoder\n    if not hasattr(file, 'read'):\n        with io.open(file, 'r', encoding='utf-8') as f:\n            return json.load(f, object_hook=decoder.decode)\n    else:\n        return json.load(file, object_hook=decoder.decode)"}
{"i": 397, "got": "def save_json(val, pretty=False, sort=True, encoder=None):\n    \"\"\"pass\"\"\"\n    if encoder is None:\n        encoder = DateTimeEncoder\n    if pretty:\n        data = json.dumps(val, indent=4, separators=(',', ': '), sort_keys=sort, cls=encoder)\n    else:\n        data = json.dumps(val, separators=(',', ':'), sort_keys=sort, cls=encoder)\n    if not sys.version_info > (3, 0) and isinstance(data, str):\n        data = data.decode('utf-8')\n    return data"}
{"i": 398, "got": "def save_json_file(file, val, pretty=False, compact=True, sort=True, encoder=None):\n    \"\"\"pass\"\"\"\n    if encoder is None:\n        encoder = DateTimeEncoder\n    opened = False\n    if not hasattr(file, 'write'):\n        file = io.open(file, 'w', encoding='utf-8')\n        opened = True\n    try:\n        if pretty:\n            data = json.dumps(val, indent=4, separators=(',', ': '), sort_keys=sort, cls=encoder)\n        elif compact:\n            data = json.dumps(val, separators=(',', ':'), sort_keys=sort, cls=encoder)\n        else:\n            data = json.dumps(val, sort_keys=sort, cls=encoder)\n    finally:\n        if not opened:\n            file.close()\n    if not sys.version_info > (3, 0) and isinstance(data, str):\n        data = data.decode('utf-8')\n    file.write(data)"}
{"i": 399, "got": "def load_yaml_file(file):\n    \"\"\"pass\"\"\"\n    if not hasattr(file, 'read'):\n        with io.open(file, 'r', encoding='utf-8') as f:\n            return yaml.load(f, yaml.FullLoader)\n    else:\n        return yaml.load(file, yaml.FullLoader)"}
{"i": 400, "got": "def save_yaml_file(file, val):\n    \"\"\"pass\"\"\"\n    opened = False\n    if not hasattr(file, 'write'):\n        file = io.open(file, 'w', encoding='utf-8')\n        opened = True\n    try:\n        yaml.dump(val, file)\n    finally:\n        if opened:\n            file.close()"}
{"i": 401, "got": "def get_embedded_yara(self, iocid):\n    \"\"\"pass\"\"\"\n    ioc_obj = self.iocs[iocid]\n    ids_to_process = set([])\n    signatures = ''\n    for elem in ioc_obj.top_level_indicator.xpath('.//IndicatorItem[Context/@search = \"Yara/Yara\"]'):\n        signature = elem.findtext('Content')\n        signatures = signatures + '\\n' + signature\n    if signatures:\n        signatures += '\\n'\n    return signatures"}
{"i": 402, "got": "def get_yara_condition_string(self, indicator_node, parameters_node, ids_to_process, condition_string='', joining_value='or'):\n    \"\"\"pass\"\"\"\n    indicator_node_id = str(indicator_node.get('id'))\n    if indicator_node_id not in ids_to_process:\n        msg = 'Entered into get_yara_condition_string with a invalid node to walk [[}]'.format(indicator_node_id)\n        raise YaraConversionError(msg)\n    expected_tag = 'Indicator'\n    if indicator_node.tag != expected_tag:\n        raise YaraConversionError('indicator_node expected tag is [%s]' % expected_tag)\n    is_set = None\n    for param in parameters_node.xpath('.//param[@ref-id=\"{}\"]'.format(indicator_node_id)):\n        if param.attrib['name'] == 'yara/set':\n            is_set = True\n            set_count = param.findtext('value', None)\n            try:\n                temp = int(set_count)\n                if temp < 1:\n                    raise YaraConversionError('yara/set parameter value was less than 1')\n                if temp > len(indicator_node.getchildren()):\n                    msg = 'yara/set value is greater than the number of children of Indicator node [%s]' % str(indicator_node_id)\n                    raise YaraConversionError(msg)\n            except ValueError:\n                raise YaraConversionError('yara/set parameter was not a integer')\n            set_dict = {'set_count': set_count, 'set_ids': []}\n    for node in indicator_node.getchildren():\n        node_id = node.get('id')\n        safe_node_id = node_id.replace('-', '')\n        if node_id not in ids_to_process:\n            continue\n        if node.tag == 'IndicatorItem':\n            if is_set:\n                raise YaraConversionError('Cannot have Indicator nodes underneath a Indicator node with yara/set')\n            operator = node.get('operator').lower()\n            if operator not in ('or', 'and'):\n                raise YaraConversionError('Indicator@operator is not and/or. [%s] has [%s]' % (id, operator))\n            recursed_condition = self.get_yara_condition_string(node, parameters_node, ids_to_process, '', operator)\n            xp = './/param[@ref-id=\"{}\" and @name=\"yara/set\"]'.format(node_id)\n            if not parameters_node.xpath(xp) and has_siblings(node):\n                recursed_condition = '(%s)' % recursed_condition\n            if condition_string == '':\n                condition_string = recursed_condition\n            else:\n                condition_string = ' '.join([condition_string, joining_value, recursed_condition])\n        elif node.tag == 'Indicator':\n            if is_set:\n                raise YaraConversionError('Cannot have Indicator nodes underneath a Indicator node with yara/set')\n            operator = node.get('operator').lower()\n            if operator not in ('or', 'and'):\n                raise YaraConversionError('Indicator@operator is not and/or. [%s] has [%s]' % (id, operator))\n            recursed_condition = self.get_yara_condition_string(node, parameters_node, ids_to_process, '', operator)\n            xp = './/param[@ref-id=\"{}\" and @name=\"yara/set\"]'.format(node_id)\n            if not parameters_node.xpath(xp) and has_siblings(node):\n                recursed_condition = '(%s)' % recursed_condition\n            if condition_string == '':\n                condition_string = recursed_condition\n            else:\n                condition_string = ' '.join([condition_string, indicator_node.getparent().get('operator').lower(), temp_set_string])\n        else:\n            xp = './/param[@ref-id=\"{}\" and (@name=\"yara/count\" or @name=\"yara/offset/at\" or @name=\"yara/offset/in\")]'.format(node_id)\n            params = parameters_node.xpath(xp)\n            if len(params) > 1:\n                msg = 'More than one condition parameters assigned to IndicatorItem [{}]'.format(node_id)\n                raise YaraConversionError(msg)\n            for param in params:\n                param_name = param.get('name', None)\n                if param_name == 'yara/count':\n                    log.debug('Found [%s] attached to [%s]' % (param.attrib['name'], node_id))\n                    mapping = {'prefix': '#', 'identifier': '', 'condition': ' ', 'postfix': ''}\n                    use_condition_template = False\n                    negation = node.get('negate')\n                    condition = node.get('condition')\n                    search = node.xpath('Context/@search')[0]\n                    content = node.findtext('Content')\n                    yara_condition = self.condition_to_yara_map[condition]\n                    if not yara_condition:\n                        msg = 'Invalid IndicatorItem condition encountered [%s][%s]' % (str(node_id), str(condition))\n                        raise YaraConversionError(msg)\n                    if negation.lower() == 'true':\n                        negation = True\n                    else:\n                        negation = False\n                    if search == 'Yara/FileSize':\n                        mapping['prefix'] = ''\n                        mapping['identifier'] = 'filesize'\n                        mapping['postfix'] = ' ' + content\n                        mapping['condition'] = yara_condition\n                        use_condition_template = True\n                    elif search == 'Yara/RuleName':\n                        if content not in self.ioc_names_set:\n                            if mangle_name(content) in self.ioc_names_mangled_set:\n                                msg = 'Yara/RuleName is present as a mangled name.[{}][{}]'.format(mangle_name(content), node_id)\n                                log.warning(msg)\n                                content = mangle_name(content)\n                        else:\n                            log.warning('Yara/RuleName points to a name [{}] that is not in the set of IOCs being processed [{}]'.format(content, node_id))\n                        if mangle_name(content) != content:\n                            msg = 'Yara/RuleName contains characters which would cause libyara errors [{}]' % node_id\n                            raise YaraConversionError(msg)\n                        mapping['prefix'] = ''\n                        mapping['identifier'] = content\n                    else:\n                        xp = './/param[@ref-id=\"{}\" and (@name=\"yara/count\" or @name=\"yara/offset/at\" or @name=\"yara/offset/in\")]'.format(node_id)\n                        params = parameters_node.xpath(xp)\n                        if len(params) > 1:\n                            msg = 'More than one condition parameters assigned to IndicatorItem [{}]'.format(node_id)\n                            raise YaraConversionError(msg)\n                        for param in params:\n                            param_name = param.get('name', None)\n                            if param_name == 'yara/count':\n                                log.debug('Found [%s] attached to [%s]' % (param.attrib['name'], node_id))\n                                mapping['prefix'] = '#'\n                                mapping['postfix'] = ' ' + param.findtext('value')\n                                mapping['condition'] = yara_condition\n                                use_condition_template = True\n                            elif param_name == 'yara/offset/at':\n                                log.debug('Found [%s] attached to [%s]' % (param.attrib['name'], node_id))\n                                mapping['condition'] = 'at'\n                                mapping['postfix'] = ' ' + param.findtext('value')\n                                use_condition_template = True\n                            elif param_name == 'yara/offset/in':\n                                log.debug('Found [%s] attached to [%s]' % (param.attrib['name'], node_id))\n                                mapping['condition'] = 'in'\n                                mapping['postfix'] = ' ' + param.findtext('value')\n                                use_condition_template = True\n                    if use_condition_template:\n                        temp_string = self.yara_II_condition_template % mapping\n                    else:\n                        temp_string = self.yara_II_template % mapping\n                    if condition_string == '':\n                        condition_string = temp_string\n                    else:\n                        condition_string = ' '.join([condition_string, joining_value, temp_string])\n        elif node.tag == 'Indicator':\n            if is_set:\n                raise YaraConversionError('Cannot have Indicator nodes underneath a Indicator node with yara/set')\n            operator = node.get('operator').lower()\n            if operator not in ('or', 'and'):\n                raise YaraConversionError('Indicator@operator is not and/or. [%s] has [%s]' % (id, operator))\n            recursed_condition = self.get_yara_condition_string(node, parameters_node, ids_to_process, '', operator)\n            xp = './/param[@ref-id=\"{}\" and @name=\"yara/set\"]'.format(node_id)\n            if not parameters_node.xpath(xp) and has_siblings(node):\n                recursed_condition = '(%s)' % recursed_condition\n            if condition_string == '':\n                condition_string = recursed_condition\n            else:\n                condition_string = ' '.join([condition_string, indicator_node.getparent().get('operator').lower(), temp_set_string])\n    if is_set:\n        log.debug('Building set expression for [%s]' % indicator_node_id)\n        if len(set_dict['set_ids']) == 0:\n            raise YaraConversionError('yara/set processing did not yield any set ids')\n        elif len(set_dict['set_ids']) == 1:\n            log.warning('yara/set with 1 id found for node [%s]' % node_id)\n            set_ids = ''.join(set_dict['set_ids'])\n        else:\n            set_ids = ','.join(set_dict['set_ids'])\n        mapping['set_ids'] = set_ids\n        temp_set_string = self.yara_set_string_template % set_dict\n        if condition_string == '':\n            condition_string = temp_set_string\n        else:\n            condition_string = ' '.join([condition_string, indicator_node.getparent().get('operator').lower(), temp_set_string])\n    return condition_string"}
{"i": 403, "got": "def write_yara(self, output_file):\n    \"\"\"pass\"\"\"\n    fout = open(output_file, 'wb')\n    fout.write('\\n')\n    for iocid in self.yara_signatures:\n        signature = self.yara_signatures[iocid]\n        fout.write(signature)\n        fout.write('\\n')\n    fout.close()\n    return True"}
{"i": 404, "got": "def safe_makedirs(fdir):\n    \"\"\"pass\"\"\"\n    if os.path.isdir(fdir):\n        return True\n    else:\n        try:\n            os.makedirs(fdir)\n        except WindowsError as e:\n            if 'Cannot create a file when that file already exists' in e:\n                log.debug('relevant dir already exists')\n            else:\n                raise WindowsError(e)\n        return True"}
{"i": 405, "got": "def convert_to_10(self):\n    \"\"\"pass\"\"\"\n    if len(self) < 1:\n        log.error('no iocs available to modify')\n        return False\n    log.info('Converting IOCs from 1.1 to 1.0.')\n    errors = []\n    for iocid in self.iocs:\n        pruned = False\n        ioc_obj_11 = self.iocs[iocid]\n        metadata = ioc_obj_11.metadata\n        name_11 = metadata.findtext('.//short_description')\n        keywords_11 = metadata.findtext('.//keywords')\n        description_11 = metadata.findtext('.//description')\n        author_11 = metadata.findtext('.//authored_by')\n        created_date_11 = metadata.findtext('.//authored_date')\n        last_modified_date_11 = ioc_obj_11.root.get('last-modified')\n        links_11 = []\n        for link in metadata.xpath('//link'):\n            link_rel = link.get('rel')\n            link_text = link.text\n            links_11.append((link_rel, None, link_text))\n        try:\n            ioc_logic = ioc_obj_11.root.xpath('.//criteria')[0]\n        except IndexError:\n            log.exception('Could not find criteria nodes for IOC [{}].  Did you attempt to convert OpenIOC 1.0 iocs?'.format(iocid))\n            errors.append(iocid)\n            continue\n        try:\n            tlo_11 = ioc_logic.getchildren()[0]\n        except IndexError:\n            log.exception('Could not find children for the top level criteria/children nodes for IOC [{}]' .format(iocid))\n            errors.append(iocid)\n            continue\n        tlo_id = tlo_11.get('id')\n        comment_dict = {}\n        for param in ioc_obj_11.parameters.xpath('//param[@name=\"comment\"]'):\n            param_id = param.get('ref-id')\n            param_text = param.findtext('value')\n            comment_dict[param_id] = param_text\n        ioc_obj_10 = ioc_api.IOC(name=name_11, description=description_11, author=author_11, links=links_11, keywords=keywords_11, iocid=iocid)\n        ioc_obj_10.root.attrib['last-modified'] = last_modified_date_11\n        authored_date_node = ioc_obj_10.metadata.find('authored_date')\n        authored_date_node.text = created_date_11\n        ioc_obj_10.root.attrib['xmlns'] = 'http://schemas.mandiant.com/2010/ioc'\n        del ioc_obj_10.root.attrib['published-date']\n        ioc_obj_10.root.remove(ioc_obj_10.parameters)\n        ioc_obj_10.root.tag = 'ioc'\n        metadata_node = ioc_obj_10.metadata\n        criteria_node = ioc_obj_10.top_level_indicator.getparent()\n        metadata_dictionary = {}\n        for child in metadata_node:\n            metadata_dictionary[child.tag] = child\n        for tag in METADATA_REQUIRED_10:\n            if tag not in metadata_dictionary:\n                msg = 'IOC {} is missing required metadata: [{}]'.format(iocid, tag)\n                raise DowngradeError(msg)\n        for tag in METADATA_ORDER_10:\n            if tag in metadata_dictionary:\n                ioc_obj_10.root.append(metadata_dictionary.get(tag))\n        ioc_obj_10.root.remove(metadata_node)\n        ioc_obj_10.root.remove(criteria_node)\n        criteria_node.tag = 'definition'\n        ioc_obj_10.root.append(criteria_node)\n        ioc_obj_10.top_level_indicator.attrib['id'] = tlo_id\n        ids_to_skip = set()\n        indicatoritems_to_remove = set()\n        for condition_type in self.openioc_11_only_conditions:\n            for elem in ioc_logic.xpath('//IndicatorItem[@condition=\"%s\"]' % condition_type):\n                pruned = True\n                indicatoritems_to_remove.add(elem)\n        for elem in ioc_logic.xpath('//IndicatorItem[@preserve-case=\"true\"]'):\n            pruned = True\n            indicatoritems_to_remove.add(elem)\n        for elem in indicatoritems_to_remove:\n            nid = None\n            current = elem\n            if nid != tlo_id:\n                parent = current.getparent()\n                nid = parent.get('id')\n                if nid == tlo_id:\n                    current_id = current.get('id')\n                    ids_to_skip.add(current_id)\n                else:\n                    current = parent\n        try:\n            self.convert_branch(tlo_11, ioc_obj_10.top_level_indicator, ids_to_skip, comment_dict)\n        except DowngradeError:\n            log.exception('Problem converting IOC [{}]'.format(iocid))\n            errors.append(iocid)\n            continue\n        if not ioc_obj_10.top_level_indicator.getchildren():\n            self.null_pruned_iocs.add(iocid)\n        elif pruned is True:\n            self.pruned_11_iocs.add(iocid)\n        self.iocs_10[iocid] = ioc_obj_10\n    return errors"}
{"i": 406, "got": "def convert_branch(self, old_node, new_node, ids_to_skip, comment_dict=None):\n    \"\"\"pass\"\"\"\n    expected_tag = 'Indicator'\n    if old_node.tag != expected_tag:\n        raise DowngradeError('old_node expected tag is [%s]' % expected_tag)\n    if not comment_dict:\n        comment_dict = {}\n    for node in old_node.getchildren():\n        node_id = node.get('id')\n        if node_id in ids_to_skip:\n            continue\n        if node.tag == 'IndicatorItem':\n            negation = node.get('negate')\n            condition = node.get('condition')\n            if 'true' in negation.lower():\n                new_condition = condition + 'not'\n            else:\n                new_condition = condition\n            document = node.xpath('Context/@document')[0]\n            search = node.xpath('Context/@search')[0]\n            content_type = node.xpath('Content/@type')[0]\n            content = node.findtext('Content')\n            context_type = node.xpath('Context/@type')[0]\n            new_ii_node = ioc_api.make_indicatoritem_node(condition=condition, document=document, search=search, content_type=content_type, content=content, context_type=context_type, nid=node_id)\n            new_ii_node.attrib['condition'] = new_condition\n            if node_id in comment_dict:\n                comment = comment_dict[node_id]\n                comment_node = et.Element('Comment')\n                comment_node.text = comment\n                new_ii_node.append(comment_node)\n            del new_ii_node.attrib['negate']\n            del new_ii_node.attrib['preserve-case']\n            new_node.append(new_ii_node)\n        elif node.tag == 'Indicator':\n            operator = node.get('operator')\n            if operator.upper() not in ('OR', 'AND'):\n                raise DowngradeError('Indicator@operator is not AND/OR. [%s] has [%s]' % (node_id, operator))\n            new_i_node = ioc_api.make_indicator_node(operator, node_id)\n            new_node.append(new_i_node)\n            self.convert_branch(node, new_i_node, ids_to_skip, comment_dict)\n        else:\n            raise DowngradeError('node is not a Indicator/IndicatorItem')\n    return True"}
{"i": 407, "got": "def create(self, permission):\n    \"\"\"pass\"\"\"\n    parent_url = self.client.get_url(self.parent_object._manager._URL_KEY, 'GET', 'single', {'id': self.parent_object.id})\n    target_url = parent_url + self.client.get_url_path(self._URL_KEY, 'POST', 'single')\n    r = self.client.request('POST', target_url, json=permission._serialize())\n    return permission._deserialize(r.json(), self)"}
{"i": 408, "got": "def set(self, permissions):\n    \"\"\"pass\"\"\"\n    parent_url = self.client.get_url(self.parent_object._manager._URL_KEY, 'GET', 'single', {'id': self.parent_object.id})\n    target_url = parent_url + self.client.get_url_path(self._URL_KEY, 'PUT', 'multi')\n    r = self.client.request('PUT', target_url, json=permissions)\n    if r.status_code != 201:\n        raise exceptions.ServerError('Expected 201 response, got %s: %s' % (r.status_code, target_url))\n    return self.list()"}
{"i": 409, "got": "def list(self):\n    \"\"\"pass\"\"\"\n    parent_url = self.client.get_url(self.parent_object._manager._URL_KEY, 'GET', 'single', {'id': self.parent_object.id})\n    target_url = parent_url + self.client.get_url_path(self._URL_KEY, 'GET', 'multi')\n    return base.Query(self, target_url)"}
{"i": 410, "got": "def get(self, permission_id, expand=[]):\n    \"\"\"pass\"\"\"\n    parent_url = self.client.get_url(self.parent_object._manager._URL_KEY, 'GET', 'single', {'id': self.parent_object.id})\n    target_url = parent_url + self.client.get_url_path(self._URL_KEY, 'GET', 'single', {'permission_id': permission_id})\n    return self._get(target_url, expand=expand)"}
{"i": 411, "got": "def get_config():\n    \"\"\"pass\"\"\"\n    configpath = get_configpath()\n    if not configpath.exists():\n        raise IOError('Config file {} not found.'.format(str(configpath)))\n    config = configparser.ConfigParser()\n    config.read(str(configpath))\n    return config"}
{"i": 412, "got": "def set_database_path(dbfolder):\n    \"\"\"pass\"\"\"\n    configpath = get_configpath()\n    try:\n        d = get_config()\n    except IOError:\n        d = configparser.ConfigParser()\n        d['pyciss_db'] = {}\n    d['pyciss_db']['path'] = dbfolder\n    with configpath.open('w') as f:\n        d.write(f)\n    print('Saved database path into {}.'.format(configpath))"}
{"i": 413, "got": "def get_db_root():\n    \"\"\"pass\"\"\"\n    d = get_config()\n    dbroot = Path(d['pyciss_db']['path'])\n    dbroot.mkdir(exist_ok=True)\n    return dbroot"}
{"i": 414, "got": "def print_db_stats():\n    \"\"\"pass\"\"\"\n    dbroot = get_db_root()\n    n_ids = len(list(dbroot.glob('[N,W]*')))\n    print('Number of WACs and NACs in database: {}'.format(n_ids))\n    print('These kind of data are in the database: (returning pd.DataFrame)')\n    d = {}\n    for key, val in PathManager.extensions.items():\n        d[key] = [len(list(dbroot.glob('**/*' + val)))]\n    return pd.DataFrame(d)"}
{"i": 415, "got": "def is_lossy(label):\n    \"\"\"pass\"\"\"\n    val = getkey(from_=label, keyword='INST_CMPRS_TYPE').decode().strip()\n    if val == 'LOSSY':\n        return True\n    else:\n        return False"}
{"i": 416, "got": "def download_and_calibrate_parallel(list_of_ids, n=None):\n    \"\"\"pass\"\"\"\n    setup_cluster(n_cores=n)\n    c = Client()\n    lbview = c.load_balanced_view()\n    lbview.map_async(download_and_calibrate, list_of_ids)\n    subprocess.Popen(['ipcluster', 'stop', '--quiet'])"}
{"i": 417, "got": "def _set_supported_content_type(self, content_types_supported):\n    \"\"\"pass\"\"\"\n    if not isinstance(content_types_supported, list):\n        raise TypeError(\"Settings 'READTIME_CONTENT_SUPPORT' must bea list of content types.\")\n    self.content_type_supported = content_types_supported"}
{"i": 418, "got": "def _set_lang_settings(self, lang_settings):\n    \"\"\"pass\"\"\"\n    is_int = isinstance(lang_settings, int)\n    is_dict = isinstance(lang_settings, dict)\n    if not (is_int or is_dict):\n        raise TypeError(\"Settings 'READTIME_WPM' must be either an int,or a dict with settings per language.\")\n    if is_int:\n        self.lang_settings['default']['wpm'] = lang_settings\n    elif is_dict:\n        for lang, conf in lang_settings.items():\n            if not 'wpm' in conf:\n                raise KeyError('Missing wpm value for thelanguage: {}'.format(lang))\n            if not isinstance(conf['wpm'], int):\n                raise TypeError('WPM is not an integer for the language: {}'.format(lang))\n            if not 'min_singular' in conf:\n                raise KeyError('Missing singular form for \"minute\" for the language: {}'.format(lang))\n            if not 'min_plural' in conf:\n                raise KeyError('Missing plural form for \"minutes\" for the language: {}'.format(lang))\n            if not 'sec_singular' in conf:\n                raise KeyError('Missing singular form for \"second\" for the language: {}'.format(lang))\n            if not 'sec_plural' in conf:\n                raise KeyError('Missing plural form for \"seconds\" for the language: {}'.format(lang))\n        self.lang_settings = lang_settings"}
{"i": 419, "got": "def initialize_settings(self, sender):\n    \"\"\"pass\"\"\"\n    try:\n        self.initialized = True\n        settings_content_types = sender.settings.get('READTIME_CONTENT_SUPPORT', self.content_type_supported)\n        self._set_supported_content_type(settings_content_types)\n        lang_settings = sender.settings.get('READTIME_WPM', self.lang_settings)\n        self._set_lang_settings(lang_settings)\n    except Exception as e:\n        raise Exception('ReadTime Plugin: %s' % str(e))"}
{"i": 420, "got": "def read_time(self, content):\n    \"\"\"pass\"\"\"\n    if get_class_name(content) in self.content_type_supported:\n        if hasattr(content, 'readtime'):\n            return\n        default_lang_conf = self.lang_settings['default']\n        lang_conf = self.lang_settings.get(content.lang, default_lang_conf)\n        avg_reading_wpm = lang_conf['wpm']\n        num_words = len(content._content.split())\n        minutes = num_words // avg_reading_wpm\n        seconds = int(num_words / avg_reading_wpm * 60 - minutes * 60)\n        minutes_str = self.pluralize(minutes, lang_conf['min_singular'], lang_conf['min_plural'])\n        seconds_str = self.pluralize(seconds, lang_conf['sec_singular'], lang_conf['sec_plural'])\n        content.readtime = minutes\n        content.readtime_string = minutes_str\n        content.readtime_with_seconds = (minutes, seconds)\n        content.readtime_string_with_seconds = '{}, {}'.format(minutes_str, seconds_str)"}
{"i": 421, "got": "def pluralize(self, measure, singular, plural):\n    \"\"\"pass\"\"\"\n    if measure == 1:\n        return '{} {}'.format(measure, singular)\n    else:\n        return '{} {}'.format(measure, plural)"}
{"i": 422, "got": "def list_datasources(self, source_id):\n    \"\"\"pass\"\"\"\n    target_url = self.client.get_url('DATASOURCE', 'GET', 'multi', {'source_id': source_id})\n    return base.Query(self.client.get_manager(Datasource), target_url)"}
{"i": 423, "got": "def get_datasource(self, source_id, datasource_id):\n    \"\"\"pass\"\"\"\n    target_url = self.client.get_url('DATASOURCE', 'GET', 'single', {'source_id': source_id, 'datasource_id': datasource_id})\n    return self.client.get_manager(Datasource)._get(target_url)"}
{"i": 424, "got": "def open_store_variable(self, name, var):\n    \"\"\"pass\"\"\"\n    data = indexing.LazilyOuterIndexedArray(CDMArrayWrapper(name, self))\n    return Variable(var.dimensions, data, {a: getattr(var, a) for a in var.ncattrs()})"}
{"i": 425, "got": "def get_attrs(self):\n    \"\"\"pass\"\"\"\n    return FrozenOrderedDict(((a, getattr(self.ds, a)) for a in self.ds.ncattrs()))"}
{"i": 426, "got": "def get_dimensions(self):\n    \"\"\"pass\"\"\"\n    return FrozenOrderedDict(((k, len(v)) for k, v in self.ds.dimensions.items()))"}
{"i": 427, "got": "def _find_base_tds_url(catalog_url):\n    \"\"\"pass\"\"\"\n    url_components = urlparse(catalog_url)\n    if url_components.path:\n        return catalog_url.split(url_components.path)[0]\n    else:\n        return catalog_url"}
{"i": 428, "got": "def filter_time_nearest(self, time, regex=None):\n    \"\"\"pass\"\"\"\n    return min(self._get_datasets_with_times(regex), key=lambda i: abs((i[0] - time).total_seconds()))[-1]"}
{"i": 429, "got": "def filter_time_range(self, start, end, regex=None):\n    \"\"\"pass\"\"\"\n    return [item[-1] for item in self._get_datasets_with_times(regex) if start <= item[0] <= end]"}
{"i": 430, "got": "def check_token(func):\n    \"\"\"pass\"\"\"\n\n    @wraps(func)\n    def wrapper(*args, **kwargs):\n        response = func(*args, **kwargs)\n        if response.status_code == 401:\n            raise InvalidToken('Access token invalid or no longer valid')\n        return response\n    return wrapper"}
{"i": 431, "got": "def upload(self, remote_path, file_content, ondup=None, **kwargs):\n    \"\"\"pass\"\"\"\n    params = {'path': remote_path, 'ondup': ondup}\n    files = {'file': ('file', file_content, '')}\n    url = 'https://c.pcs.baidu.com/rest/2.0/pcs/file'\n    return self._request('file', 'upload', url=url, extra_params=params, files=files, **kwargs)"}
{"i": 432, "got": "def upload_tmpfile(self, file_content, **kwargs):\n    \"\"\"pass\"\"\"\n    params = {'type': 'tmpfile'}\n    files = {'file': ('file', file_content, '')}\n    url = 'https://c.pcs.baidu.com/rest/2.0/pcs/file'\n    return self._request('file', 'upload', url=url, extra_params=params, files=files, **kwargs)"}
{"i": 433, "got": "def upload_superfile(self, remote_path, block_list, ondup=None, **kwargs):\n    \"\"\"pass\"\"\"\n    params = {'path': remote_path, 'ondup': ondup}\n    data = {'param': json.dumps({'block_list': block_list})}\n    return self._request('file', 'createsuperfile', extra_params=params, data=data, **kwargs)"}
{"i": 434, "got": "def mkdir(self, remote_path, **kwargs):\n    \"\"\"pass\"\"\"\n    data = {'path': remote_path}\n    return self._request('file', 'mkdir', data=data, **kwargs)"}
{"i": 435, "got": "def meta(self, remote_path, **kwargs):\n    \"\"\"pass\"\"\"\n    params = {'path': remote_path}\n    return self._request('file', 'meta', extra_params=params, **kwargs)"}
{"i": 436, "got": "def login(self):\n    \"\"\"pass\"\"\"\n    if os.path.exists(self._cookieFileName):\n        with open(self._cookieFileName, 'r') as cookieFile:\n            self._vid = cookieFile.read().strip()\n        try:\n            self._get_installations()\n        except ResponseError:\n            self._vid = None\n            os.remove(self._cookieFileName)\n    if self._vid is None:\n        self._create_cookie()\n        with open(self._cookieFileName, 'w') as cookieFile:\n            cookieFile.write(self._vid)\n        self._get_installations()\n    self._giid = self.installations[0]['giid']"}
{"i": 437, "got": "def _get_installations(self):\n    \"\"\"pass\"\"\"\n    response = None\n    for base_url in urls.BASE_URLS:\n        urls.BASE_URL = base_url\n        try:\n            response = requests.get(urls.get_installations(self._username), headers={'Cookie': 'vid={}'.format(self._vid), 'Accept': 'application/json,text/javascript, */*; q=0.01'})\n            if 2 == response.status_code // 100:\n                break\n            elif 503 == response.status_code:\n                continue\n            else:\n                raise ResponseError(response.status_code, response.text)\n        except requests.exceptions.RequestException as ex:\n            raise RequestError(ex)\n    _validate_response(response)\n    self.installations = json.loads(response.text)"}
{"i": 438, "got": "def get_overview(self):\n    \"\"\"pass\"\"\"\n    response = None\n    try:\n        response = requests.get(urls.overview(self._giid), headers={'Accept': 'application/json, text/javascript, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate', 'Content-Type': 'application/json', 'Cookie': 'vid={}'.format(self._vid)})\n    except requests.exceptions.RequestException as ex:\n        raise RequestError(ex)\n    _validate_response(response)\n    return json.loads(response.text)"}
{"i": 439, "got": "def set_smartplug_state(self, device_label, state):\n    \"\"\"pass\"\"\"\n    response = None\n    try:\n        response = requests.post(urls.smartplug(self._giid), headers={'Content-Type': 'application/json', 'Cookie': 'vid={}'.format(self._vid)}, data=json.dumps([{'deviceLabel': device_label, 'state': state}]))\n    except requests.exceptions.RequestException as ex:\n        raise RequestError(ex)\n    _validate_response(response)"}
{"i": 440, "got": "def get_history(self, filters=(), pagesize=15, offset=0):\n    \"\"\"pass\"\"\"\n    response = None\n    try:\n        response = requests.get(urls.history(self._giid), headers={'Accept': 'application/json, text/javascript, */*; q=0.01', 'Cookie': 'vid={}'.format(self._vid)}, params={'offset': int(offset), 'pagesize': int(pagesize), 'notificationCategories': filters})\n    except requests.exceptions.RequestException as ex:\n        raise RequestError(ex)\n    _validate_response(response)\n    return json.loads(response.text)"}
{"i": 441, "got": "def get_climate(self, device_label):\n    \"\"\"pass\"\"\"\n    response = None\n    try:\n        response = requests.get(urls.climate(self._giid), headers={'Accept': 'application/json, text/javascript, */*; q=0.01', 'Cookie': 'vid={}'.format(self._vid)}, params={'deviceLabel': device_label})\n    except requests.exceptions.RequestException as ex:\n        raise RequestError(ex)\n    _validate_response(response)\n    return json.loads(response.text)"}
{"i": 442, "got": "def type_id(self):\n    \"\"\"pass\"\"\"\n    try:\n        return ContentType.objects.get_for_model(self.model, for_concrete_model=False).id\n    except DatabaseError as e:\n        raise DatabaseError('Unable to fetch ContentType object, is a plugin being registered before the initial syncdb? (original error: {0})'.format(str(e)))"}
{"i": 443, "got": "def get_output_cache_key(self, placeholder_name, instance):\n    \"\"\"pass\"\"\"\n    cachekey = self.get_output_cache_base_key(placeholder_name, instance)\n    if self.cache_output_per_site:\n        cachekey = '{0}-s{1}'.format(cachekey, settings.SITE_ID)\n    if self.cache_output_per_language:\n        user_language = get_language()\n        if user_language not in self.cache_supported_language_codes:\n            user_language = 'unsupported'\n        cachekey = '{0}.{1}'.format(cachekey, user_language)\n    return cachekey"}
{"i": 444, "got": "def get_output_cache_keys(self, placeholder_name, instance):\n    \"\"\"pass\"\"\"\n    base_key = self.get_output_cache_base_key(placeholder_name, instance)\n    cachekeys = [base_key]\n    if self.cache_output_per_site:\n        site_ids = list(Site.objects.values_list('pk', flat=True))\n        if settings.SITE_ID not in site_ids:\n            site_ids.append(settings.SITE_ID)\n        base_key = get_rendering_cache_key(placeholder_name, instance)\n        cachekeys = ['{0}-s{1}'.format(base_key, site_id) for site_id in site_ids]\n    if self.cache_output_per_language or self.render_ignore_item_language:\n        total_list = []\n        cache_languages = list(self.cache_supported_language_codes) + ['unsupported', 'None']\n        placeholder = instance.placeholder\n        total_list.extend((get_placeholder_cache_key(placeholder, lc) for lc in cache_languages))\n        for user_language in cache_languages:\n            total_list.extend(('{0}.{1}'.format(base, user_language) for base in cachekeys))\n        cachekeys = total_list\n    return cachekeys"}
{"i": 445, "got": "def get_cached_output(self, placeholder_name, instance):\n    \"\"\"pass\"\"\"\n    cachekey = self.get_output_cache_key(placeholder_name, instance)\n    return cache.get(cachekey)"}
{"i": 446, "got": "def set_cached_output(self, placeholder_name, instance, output):\n    \"\"\"pass\"\"\"\n    cachekey = self.get_output_cache_key(placeholder_name, instance)\n    if self.cache_timeout is not DEFAULT_TIMEOUT:\n        cache.set(cachekey, output, self.cache_timeout)\n    else:\n        cache.set(cachekey, output)"}
{"i": 447, "got": "def render(self, request, instance, **kwargs):\n    \"\"\"pass\"\"\"\n    render_template = self.get_render_template(request, instance, **kwargs)\n    if not render_template:\n        return str(_(\"{No rendering defined for class '%s'}\" % self.__class__.__name__))\n    context = self.get_context(request, instance, **kwargs)\n    return self.render_to_string(request, render_template, context)"}
{"i": 448, "got": "def inline_requests(method_or_func):\n    \"\"\"pass\"\"\"\n    args = get_args(method_or_func)\n    if not args:\n        raise TypeError('Function must accept at least one argument.')\n    if args[0] == 'self':\n\n        def wrapper(self, response, **kwargs):\n            callback = create_bound_method(method_or_func, self)\n            genwrapper = RequestGenerator(callback, **kwargs)\n            return genwrapper(response)\n    else:\n        warnings.warn('Decorating a non-method function will be deprecated', ScrapyDeprecationWarning, stacklevel=1)\n\n        def wrapper(response, **kwargs):\n            genwrapper = RequestGenerator(method_or_func, **kwargs)\n            return genwrapper(response)\n    return wraps(method_or_func)(wrapper)"}
{"i": 449, "got": "def get_args(method_or_func):\n    \"\"\"pass\"\"\"\n    try:\n        args = list(inspect.signature(method_or_func).parameters.keys())\n    except AttributeError:\n        args = inspect.getargspec(method_or_func).args\n    return args"}
{"i": 450, "got": "def _unwindGenerator(self, generator, _prev=None):\n    \"\"\"pass\"\"\"\n    while True:\n        if _prev:\n            ret, _prev = (_prev, None)\n        else:\n            try:\n                ret = next(generator)\n            except StopIteration:\n                return\n        if isinstance(ret, Request):\n            if ret.callback:\n                warnings.warn('Got a request with callback set, bypassing the generator wrapper. Generator may not be able to resume. %s' % ret)\n            elif ret.errback:\n                warnings.warn('Got a request with errback set, bypassing the generator wrapper. Generator may not be able to resume. %s' % ret)\n            else:\n                yield self._wrapRequest(ret, generator)\n        else:\n            yield ret"}
{"i": 451, "got": "def jwt_required(fn):\n    \"\"\"pass\"\"\"\n\n    @wraps(fn)\n    def wrapper(*args, **kwargs):\n        jwt_data = _decode_jwt_from_headers()\n        ctx_stack.top.jwt = jwt_data\n        return fn(*args, **kwargs)\n    return wrapper"}
{"i": 452, "got": "def jwt_optional(fn):\n    \"\"\"pass\"\"\"\n\n    @wraps(fn)\n    def wrapper(*args, **kwargs):\n        try:\n            jwt_data = _decode_jwt_from_headers()\n            ctx_stack.top.jwt = jwt_data\n        except (NoAuthorizationError, InvalidHeaderError):\n            pass\n        return fn(*args, **kwargs)\n    return wrapper"}
{"i": 453, "got": "def decode_jwt(encoded_token):\n    \"\"\"pass\"\"\"\n    secret = config.decode_key\n    algorithm = config.algorithm\n    audience = config.audience\n    return jwt.decode(encoded_token, secret, algorithms=[algorithm], audience=audience)"}
{"i": 454, "got": "def init_app(self, app):\n    \"\"\"pass\"\"\"\n    if not hasattr(app, 'extensions'):\n        app.extensions = {}\n    app.extensions['flask-jwt-simple'] = self\n    self._set_default_configuration_options(app)\n    self._set_error_handler_callbacks(app)\n    app.config['PROPAGATE_EXCEPTIONS'] = True"}
{"i": 455, "got": "def _set_error_handler_callbacks(self, app):\n    \"\"\"pass\"\"\"\n\n    @app.errorhandler(NoAuthorizationError)\n    def handle_no_auth_error(e):\n        return self._unauthorized_callback(str(e))\n\n    @app.errorhandler(InvalidHeaderError)\n    def handle_invalid_header_error(e):\n        return self._invalid_token_callback(str(e))\n\n    @app.errorhandler(jwt.ExpiredSignatureError)\n    def handle_expired_error(e):\n        return self._expired_token_callback()\n\n    @app.errorhandler(jwt.InvalidTokenError)\n    def handle_invalid_token_error(e):\n        return self._invalid_token_callback(str(e))"}
{"i": 456, "got": "def _set_default_configuration_options(app):\n    \"\"\"pass\"\"\"\n    app.config.setdefault('JWT_HEADER_NAME', 'Authorization')\n    app.config.setdefault('JWT_HEADER_TYPE', 'Bearer')\n    app.config.setdefault('JWT_EXPIRES', datetime.timedelta(hours=1))\n    app.config.setdefault('JWT_ALGORITHM', 'HS256')\n    app.config.setdefault('JWT_IDENTITY_CLAIM', 'sub')\n    app.config.setdefault('JWT_DECODE_AUDIENCE', None)\n    app.config.setdefault('JWT_SECRET_KEY', None)\n    app.config.setdefault('JWT_PRIVATE_KEY', None)\n    app.config.setdefault('JWT_PUBLIC_KEY', None)"}
{"i": 457, "got": "def category(**kwargs):\n    \"\"\"pass\"\"\"\n    if 'series' in kwargs:\n        kwargs.pop('series')\n        path = 'series'\n    else:\n        path = None\n    return Fred().category(path, **kwargs)"}
{"i": 458, "got": "def releases(release_id=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if 'id' not in kwargs and release_id is not None:\n        kwargs['release_id'] = release_id\n        return Fred().release(**kwargs)\n    else:\n        return Fred().releases(**kwargs)"}
{"i": 459, "got": "def series(identifier=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if identifier:\n        kwargs['series_id'] = identifier\n    if 'release' in kwargs:\n        kwargs.pop('release')\n        path = 'release'\n    elif 'releases' in kwargs:\n        kwargs.pop('releases')\n        path = 'release'\n    else:\n        path = None\n    return Fred().series(path, **kwargs)"}
{"i": 460, "got": "def source(source_id=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if source_id is not None:\n        kwargs['source_id'] = source_id\n    elif 'id' in kwargs:\n        source_id = kwargs.pop('id')\n        kwargs['source_id'] = source_id\n    if 'releases' in kwargs:\n        kwargs.pop('releases')\n        path = 'releases'\n    else:\n        path = None\n    return Fred().source(path, **kwargs)"}
{"i": 461, "got": "def sources(source_id=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if source_id or 'id' in kwargs:\n        return source(source_id, **kwargs)\n    else:\n        return Fred().sources(**kwargs)"}
{"i": 462, "got": "def _create_path(self, *args):\n    \"\"\"pass\"\"\"\n    args = filter(None, args)\n    path = self.endpoint + '/'.join(args)\n    return path"}
{"i": 463, "got": "def item_extra_kwargs(self, item):\n    \"\"\"pass\"\"\"\n    if use_feed_image:\n        feed_image = item.feed_image\n        if feed_image:\n            image_complete_url = urljoin(self.get_site_url(), feed_image.file.url)\n        else:\n            image_complete_url = ''\n    content_field = getattr(item, self.item_content_field)\n    try:\n        content = expand_db_html(content_field)\n    except:\n        content = content_field.__html__()\n    soup = BeautifulSoup(content, 'html.parser')\n    for div in soup.find_all('div', {'class': 'responsive-object'}):\n        del div['style']\n    for img_tag in soup.findAll('img'):\n        if not img_tag.has_attr('src'):\n            continue\n        img_tag['src'] = urljoin(self.get_site_url(), img_tag['src'])\n    fields_to_add = {'content': soup.prettify(formatter='html')}\n    if use_feed_image:\n        fields_to_add['image'] = image_complete_url\n    else:\n        fields_to_add['image'] = ''\n    return fields_to_add"}
{"i": 464, "got": "def treenav_undefined_url(request, item_slug):\n    \"\"\"pass\"\"\"\n    item = get_object_or_404(treenav.MenuItem, slug=item_slug)\n    raise Http404"}
{"i": 465, "got": "def treenav_save_other_object_handler(sender, instance, created, **kwargs):\n    \"\"\"pass\"\"\"\n    from django.contrib.contenttypes.models import ContentType\n    from .models import MenuItem\n    cache_key = 'django-treenav-menumodels'\n    if sender == MenuItem:\n        cache.delete(cache_key)\n    menu_models = cache.get(cache_key)\n    if not menu_models:\n        menu_models = []\n        for menu_item in MenuItem.objects.exclude(content_type__isnull=True):\n            menu_models.append(menu_item.content_type.model_class())\n        cache.set(cache_key, menu_models)\n    if sender in menu_models:\n        ct = ContentType.objects.get_for_model(sender)\n        items = MenuItem.objects.filter(content_type=ct, object_id=instance.pk)\n        for item in items:\n            if item.href != instance.get_absolute_url():\n                item.href = instance.get_absolute_url()\n                item.save()"}
{"i": 466, "got": "def refresh_hrefs(self, request):\n    \"\"\"pass\"\"\"\n    for item in treenav.MenuItem.objects.all():\n        item.save()\n    self.message_user(request, _('Menu item HREFs refreshed successfully.'))\n    info = (self.model._meta.app_label, self.model._meta.model_name)\n    changelist_url = reverse('admin:%s_%s_changelist' % info, current_app=self.admin_site.name)\n    return redirect(changelist_url)"}
{"i": 467, "got": "def clean_cache(self, request):\n    \"\"\"pass\"\"\"\n    treenav.delete_cache()\n    self.message_user(request, _('Cache menuitem cache cleaned successfully.'))\n    info = (self.model._meta.app_label, self.model._meta.model_name)\n    changelist_url = reverse('admin:%s_%s_changelist' % info, current_app=self.admin_site.name)\n    return redirect(changelist_url)"}
{"i": 468, "got": "def rebuild_tree(self, request):\n    \"\"\"pass\"\"\"\n    self.model.objects.rebuild()\n    self.message_user(request, _('Menu Tree Rebuilt.'))\n    return self.clean_cache(request)"}
{"i": 469, "got": "def save_related(self, request, form, formsets, change):\n    \"\"\"pass\"\"\"\n    super(MenuItemAdmin, self).save_related(request, form, formsets, change)\n    self.model.objects.rebuild()"}
{"i": 470, "got": "def _calculate_dispersion(X: Union[pd.DataFrame, np.ndarray], labels: np.ndarray, centroids: np.ndarray) -> float:\n    \"\"\"pass\"\"\"\n    disp = np.sum(np.sum([np.abs(inst - centroids[label]) ** 2 for inst, label in zip(X, labels)]))\n    return disp"}
{"i": 471, "got": "def _calculate_gap(self, X: Union[pd.DataFrame, np.ndarray], n_refs: int, n_clusters: int) -> Tuple[float, int]:\n    \"\"\"pass\"\"\"\n    ref_dispersions = np.zeros(n_refs)\n    for i in range(n_refs):\n        random_data = np.random.random_sample(size=X.shape)\n        centroids, labels = kmeans2(data=random_data, k=n_clusters, iter=10, minit='points')\n        dispersion = self._calculate_dispersion(X=random_data, labels=labels, centroids=centroids)\n        ref_dispersions[i] = dispersion\n    centroids, labels = kmeans2(data=X, k=n_clusters, iter=10, minit='points')\n    dispersion = self._calculate_dispersion(X=X, labels=labels, centroids=centroids)\n    gap_value = np.mean(np.log(ref_dispersions)) - np.log(dispersion)\n    return (gap_value, int(n_clusters))"}
{"i": 472, "got": "def _process_with_rust(self, X: Union[pd.DataFrame, np.ndarray], n_refs: int, cluster_array: np.ndarray):\n    \"\"\"pass\"\"\"\n    from gap_statistic.rust import gapstat\n    for label, gap_value in gapstat.optimal_k(X, list(cluster_array)):\n        yield (gap_value, label)"}
{"i": 473, "got": "def _process_with_joblib(self, X: Union[pd.DataFrame, np.ndarray], n_refs: int, cluster_array: np.ndarray):\n    \"\"\"pass\"\"\"\n    if Parallel is None:\n        raise EnvironmentError('joblib is not installed; cannot use joblib as the parallel backend!')\n    with Parallel(n_jobs=self.n_jobs) as parallel:\n        for gap_value, n_clusters in parallel((delayed(self._calculate_gap)(X, n_refs, n_clusters) for n_clusters in cluster_array)):\n            yield (gap_value, n_clusters)"}
{"i": 474, "got": "def _process_with_multiprocessing(self, X: Union[pd.DataFrame, np.ndarray], n_refs: int, cluster_array: np.ndarray):\n    \"\"\"pass\"\"\"\n    with ProcessPoolExecutor(max_workers=self.n_jobs) as executor:\n        jobs = [executor.submit(self._calculate_gap, X, n_refs, n_clusters) for n_clusters in cluster_array]\n        for future in as_completed(jobs):\n            gap_value, k = future.result()\n            yield (gap_value, k)"}
{"i": 475, "got": "def _process_non_parallel(self, X: Union[pd.DataFrame, np.ndarray], n_refs: int, cluster_array: np.ndarray):\n    \"\"\"pass\"\"\"\n    for gap_value, n_clusters in [self._calculate_gap(X, n_refs, n_clusters) for n_clusters in cluster_array]:\n        yield (gap_value, n_clusters)"}
{"i": 476, "got": "def get_last(self):\n    \"\"\"pass\"\"\"\n    query = self.table().where('batch', self.get_last_batch_number())\n    return query.order_by('migration', 'desc').get()"}
{"i": 477, "got": "def compile_insert(self, query, values):\n    \"\"\"pass\"\"\"\n    table = self.wrap_table(query.from__)\n    if not isinstance(values, list):\n        values = [values]\n    columns = self.columnize(values[0].keys())\n    parameters = self.parameterize(values[0].values())\n    value = ['(%s)' % parameters] * len(values)\n    parameters = ', '.join(value)\n    return 'INSERT INTO %s (%s) VALUES %s' % (table, columns, parameters)"}
{"i": 478, "got": "def get_alter_table_sql(self, diff):\n    \"\"\"pass\"\"\"\n    sql = []\n    for column_diff in diff.changed_columns.values():\n        if self.is_unchanged_binary_column(column_diff):\n            continue\n        old_column_name = column_diff.old_column_name\n        column = column_diff.column\n        if any([column_diff.has_changed('type'), column_diff.has_changed('precision'), column_diff.has_changed('scale'), column_diff.has_changed('fixed')]):\n            query = 'ALTER ' + old_column_name + ' TYPE ' + self.get_sql_type_declaration(column.to_dict())\n            sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n        if column_diff.has_changed('default') or column_diff.has_changed('type'):\n            if column.get_default() is None:\n                default_clause = ' DROP DEFAULT'\n            else:\n                default_clause = ' SET' + self.get_default_value_declaration_sql(column.to_dict())\n            query = 'ALTER ' + old_column_name + default_clause\n            sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n        if column_diff.has_changed('notnull'):\n            op = 'DROP'\n            if column.get_notnull():\n                op = 'SET'\n            query = 'ALTER ' + old_column_name + ' ' + op + ' NOT NULL'\n            sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n        if column_diff.has_changed('autoincrement'):\n            if column.get_autoincrement():\n                seq_name = self.get_identity_sequence_name(diff.name, old_column_name)\n                sql.append('CREATE SEQUENCE ' + seq_name)\n                sql.append(\"SELECT setval('\" + seq_name + \"', (SELECT MAX(\" + old_column_name + ') FROM ' + diff.name + '))\")\n                query = 'ALTER ' + old_column_name + \" SET DEFAULT nextval('\" + seq_name + \"')\"\n                sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n            else:\n                query = 'ALTER ' + old_column_name + ' DROP DEFAULT'\n                sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n        if column_diff.has_changed('length'):\n            query = 'ALTER ' + old_column_name + ' TYPE ' + self.get_sql_type_declaration(column.to_dict())\n            sql.append('ALTER TABLE ' + diff.name + ' ' + query)\n    for old_column_name, column in diff.renamed_columns.items():\n        sql.append('ALTER TABLE ' + diff.name + ' RENAME COLUMN ' + old_column_name + ' TO ' + column.get_name())\n    return sql"}
{"i": 479, "got": "def _date_based_where(self, type, query, where):\n    \"\"\"pass\"\"\"\n    value = str(where['value']).zfill(2)\n    value = self.parameter(value)\n    return \"strftime('%s', %s) %s %s\" % (type, self.wrap(where['column']), where['operator'], value)"}
{"i": 480, "got": "def compile_select(self, query):\n    \"\"\"pass\"\"\"\n    sql = super(MySqlQueryGrammar, self).compile_select(query)\n    if query.unions:\n        sql = '%s %s' % (sql, self._compile_unions(query))\n    return sql"}
{"i": 481, "got": "def _compile_lock(self, query, value):\n    \"\"\"pass\"\"\"\n    if isinstance(value, basestring):\n        return value\n    elif value is True:\n        return 'FOR UPDATE'\n    elif value is False:\n        return 'LOCK IN SHARE MODE'"}
{"i": 482, "got": "def plot_best_worst_fits(assignments_df, data, modality_col='Modality', score='$\\\\log_2 K$'):\n    \"\"\"pass\"\"\"\n    ncols = 2\n    nrows = len(assignments_df.groupby(modality_col).groups.keys())\n    fig, axes = plt.subplots(nrows=nrows, ncols=ncols * 4, figsize=(ncols * 6, 4))\n    axes_iter = axes.flat\n    fits = ('Highest', 'Lowest')\n    for modality, df in assignments_df.groupby(modality_col):\n        df = df.sort_values(score)\n        color = MODALITY_TO_COLOR[modality]\n        for fit in fits:\n            if fit == 'Highest':\n                ids = df['Feature ID'][-10:]\n            else:\n                ids = df['Feature ID'][:10]\n            fit_psi = data[ids]\n            tidy_fit_psi = fit_psi.stack().reset_index()\n            tidy_fit_psi = tidy_fit_psi.rename(columns={'level_0': 'Sample ID', 'level_1': 'Feature ID', 0: '$\\\\Psi$'})\n            if not tidy_fit_psi.empty:\n                continue\n            ax = six.next(axes_iter)\n            violinplot(x='Feature ID', y='$\\\\Psi$', data=tidy_fit_psi, color=color, ax=ax)\n            ax.set(title='{} {} {}'.format(fit, score, modality), xticks=[])\n    sns.despine()\n    fig.tight_layout()"}
{"i": 483, "got": "def violinplot(x=None, y=None, data=None, bw=0.2, scale='width', inner=None, ax=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if ax is None:\n        ax = plt.gca()\n    sns.violinplot(x, y, data=data, bw=bw, scale=scale, inner=inner, ax=ax, **kwargs)\n    ax.set(ylim=(0, 1), yticks=(0, 0.5, 1))\n    return ax"}
{"i": 484, "got": "def bar(self, counts, phenotype_to_color=None, ax=None, percentages=True):\n    \"\"\"pass\"\"\"\n    if percentages:\n        counts = (100 * (counts.T / counts.T.sum()).T)\n    if ax is None:\n        ax = plt.gca()\n    full_width = 0.8\n    width = full_width / counts.shape[0]\n    for i, (group, series) in enumerate(counts.iterrows()):\n        left = np.arange(len(self.modality_order)) + i * width\n        height = [series[i] if i in group else 0 for i in self.modality_order]\n        color = phenotype_to_color[group]\n        ax.bar(left, height, width=width, color=color, label=group, linewidth=0.5, edgecolor='k')\n    ylabel = 'Percentage of events' if percentages else 'Number of events'\n    ax.set_ylabel(ylabel)\n    ax.set_xticks(np.arange(len(self.modality_order)) + full_width / 2)\n    ax.set_xticklabels(self.modality_order)\n    ax.set_xlabel('Splicing modality')\n    ax.set_xlim(0, len(self.modality_order))\n    ax.legend(loc='best')\n    ax.grid(axis='y', linestyle='-', linewidth=0.5)\n    sns.despine()"}
{"i": 485, "got": "def event_estimation(self, event, logliks, logsumexps, renamed=''):\n    \"\"\"pass\"\"\"\n    plotter = _ModelLoglikPlotter()\n    plotter.plot(event, logliks, logsumexps, self.modality_to_color, renamed=renamed)\n    return plotter"}
{"i": 486, "got": "def predict(self, fitted):\n    \"\"\"pass\"\"\"\n    if fitted.shape[0] != len(self.modalities):\n        raise ValueError(\"This data doesn't look like it had the distance between it and the five modalities calculated\")\n    return fitted.idxmin()"}
{"i": 487, "got": "def logliks(self, x):\n    \"\"\"pass\"\"\"\n    x = x.copy()\n    x[x == 0] = VERY_SMALL_NUMBER\n    x[x == 1] = 1 - VERY_SMALL_NUMBER\n    return np.array([np.log(prob) + rv.logpdf(x[np.isfinite(x)]).sum() for prob, rv in zip(self.prob_parameters, self.rvs)])"}
{"i": 488, "got": "def get_next_value(sequence_name, initial_value, reset_value='default', *, nowait=False, using=None):\n    \"\"\"pass\"\"\"\n    from .models import Sequence\n    if reset_value is not None and (not initial_value < reset_value):\n        assert False\n    if using is None:\n        using = router.db_for_write(Sequence)\n    connection = connections[using]\n    if getattr(connection, 'pg_version', 0) >= 90500 and reset_value is None and (not nowait):\n        with connection.cursor() as cursor:\n            cursor.execute(UPSERT_QUERY, [sequence_name, initial_value])\n            last, = cursor.fetchone()\n        return last\n    else:\n        with transaction.atomic(using=using, savepoint=False):\n            sequence, created = Sequence.objects.select_for_update(nowait=nowait).get_or_create(name=sequence_name, defaults={'last': initial_value})\n            if not created:\n                sequence.last += 1\n                if reset_value is not None and sequence.last >= reset_value:\n                    sequence.last = initial_value\n                sequence.save()\n            return sequence.last"}
{"i": 489, "got": "def check(self, final_line_count):\n    \"\"\"pass\"\"\"\n    if self._lines_seen['version']:\n        self._process_version_lines()\n    self._process_plan_lines(final_line_count)"}
{"i": 490, "got": "def _process_version_lines(self):\n    \"\"\"pass\"\"\"\n    if len(self._lines_seen['version']) > 1:\n        self._add_error(_('Multiple version lines appeared.'))\n    elif self._lines_seen['version'][0] != 1:\n        self._add_error(_('The version must be on the first line.'))"}
{"i": 491, "got": "def _process_plan_lines(self, final_line_count):\n    \"\"\"pass\"\"\"\n    if not self._lines_seen['plan']:\n        self._add_error(_('Missing a plan.'))\n        return\n    elif len(self._lines_seen['plan']) > 1:\n        self._add_error(_('Only one plan line is permitted per file.'))\n        return\n    else:\n        plan, at_line = self._lines_seen['plan'][0]\n        if not self._plan_on_valid_line(at_line, final_line_count):\n            self._add_error(_('A plan must appear at the beginning or end of the file.'))\n            return\n        elif plan.expected_tests != self._lines_seen['test']:\n            self._add_error(_('Expected {expected_count} tests but only {seen_count} ran.').format(expected_count=plan.expected_tests, seen_count=self._lines_seen['test']))"}
{"i": 492, "got": "def _plan_on_valid_line(self, at_line, final_line_count):\n    \"\"\"pass\"\"\"\n    if at_line == 1 or (at_line == final_line_count):\n        return True\n    after_version = self._lines_seen['version'] and self._lines_seen['version'][0] == 1 and (at_line == 2)\n    if after_version:\n        return True\n    else:\n        return False"}
{"i": 493, "got": "def handle_bail(self, bail):\n    \"\"\"pass\"\"\"\n    self._add_error(_('Bailed: {reason}').format(reason=bail.reason))"}
{"i": 494, "got": "def handle_skipping_plan(self, skip_plan):\n    \"\"\"pass\"\"\"\n    skip_line = Result(True, None, skip_plan.directive.text, Directive('SKIP'))\n    self._suite.addTest(Adapter(self._filename, skip_line))"}
{"i": 495, "got": "def mptt_before_insert(mapper, connection, instance):\n    \"\"\"pass\"\"\"\n    table = _get_tree_table(mapper)\n    db_pk = instance.get_pk_column()\n    table_pk = getattr(table.c, db_pk.name)\n    if instance.parent_id is None:\n        instance.left = 1\n        instance.right = 2\n        instance.level = instance.get_default_level()\n        tree_id = connection.scalar(select([func.max(table.c.tree_id) + 1])) or 1\n        instance.tree_id = tree_id\n    else:\n        parent_pos_left, parent_pos_right, parent_tree_id, parent_level = connection.execute(select([table.c.lft, table.c.rgt, table.c.tree_id, table.c.level])).where(table_pk == instance.parent_id).fetchone()\n        connection.execute(table.update(and_(table.c.rgt >= parent_pos_right, table.c.tree_id == parent_tree_id)).values(lft=case([(table.c.lft > parent_pos_right, table.c.lft + 2)], else_=table.c.lft), rgt=case([(table.c.rgt >= parent_pos_right, table.c.rgt + 2)], else_=table.c.rgt)))\n        instance.level = parent_level + 1\n        instance.tree_id = parent_tree_id\n        instance.left = parent_pos_right\n        instance.right = parent_pos_right + 1"}
{"i": 496, "got": "def mptt_before_update(mapper, connection, instance):\n    \"\"\"pass\"\"\"\n    node_id = getattr(instance, instance.get_pk_name())\n    table = _get_tree_table(mapper)\n    db_pk = instance.get_pk_column()\n    default_level = instance.get_default_level()\n    table_pk = getattr(table.c, db_pk.name)\n    mptt_move_inside = None\n    left_sibling = None\n    left_sibling_tree_id = None\n    if hasattr(instance, 'mptt_move_inside'):\n        mptt_move_inside = instance.mptt_move_inside\n    if hasattr(instance, 'mptt_move_before'):\n        right_sibling_left, right_sibling_right, right_sibling_parent, right_sibling_level, right_sibling_tree_id = connection.execute(select([table.c.lft, table.c.rgt, table.c.parent_id, table.c.level, table.c.tree_id]).where(table_pk == instance.mptt_move_before)).fetchone()\n        current_lvl_nodes = connection.execute(select([table.c.lft, table.c.rgt, table.c.parent_id, table.c.tree_id]).where(and_(table.c.level == right_sibling_level, table.c.tree_id == right_sibling_tree_id, table.c.lft < right_sibling_left))).fetchall()\n        if current_lvl_nodes:\n            left_sibling_left, left_sibling_right, left_sibling_parent, left_sibling_tree_id = current_lvl_nodes[-1]\n            instance.parent_id = left_sibling_parent\n            left_sibling = {'lft': left_sibling_left, 'rgt': left_sibling_right, 'is_parent': False}\n        elif not right_sibling_parent:\n            left_sibling_tree_id = right_sibling_tree_id - 1\n    if hasattr(instance, 'mptt_move_after'):\n        left_sibling_left, left_sibling_right, left_sibling_parent, left_sibling_tree_id = connection.execute(select([table.c.lft, table.c.rgt, table.c.parent_id, table.c.tree_id]).where(table_pk == instance.mptt_move_after)).fetchone()\n        instance.parent_id = left_sibling_parent\n        left_sibling = {'lft': left_sibling_left, 'rgt': left_sibling_right, 'is_parent': False}\n    '\\n    Get the subtree\\n    '\n    subtree = connection.execute(select([table_pk]).where(and_(table.c.lft >= instance.left, table.c.rgt <= instance.right, table.c.tree_id == instance.tree_id))).order_by(table.c.lft).fetchall()\n    subtree = [x[0] for x in subtree]\n    '\\n    Get the node position\\n    '\n    node_pos_left, node_pos_right, node_tree_id, node_parent_id, node_level = connection.execute(select([table.c.lft, table.c.rgt, table.c.tree_id, table.c.parent_id, table.c.level]).where(table_pk == node_id)).fetchone()\n    if not left_sibling and str(node_parent_id) == str(instance.parent_id) and (not mptt_move_inside) and (left_sibling_tree_id is None):\n        return\n    if instance.parent_id is not None:\n        '\\n        Get the parent\\n        '\n        parent_id, parent_pos_right, parent_pos_left, parent_tree_id, parent_level = connection.execute(select([table_pk, table.c.rgt, table.c.lft, table.c.tree_id, table.c.level]).where(table_pk == instance.parent_id)).fetchone()\n        if node_parent_id is None and node_tree_id == parent_tree_id:\n            instance.parent_id = None\n            return\n    mptt_before_delete(mapper, connection, instance, False)\n    if instance.parent_id is not None:\n        '\\n        Delete the subtree\\n        '\n        parent_id, parent_pos_right, parent_pos_left, parent_tree_id, parent_level = connection.execute(select([table_pk, table.c.rgt, table.c.lft, table.c.tree_id, table.c.level]).where(table_pk == instance.parent_id)).fetchone()\n        node_size = node_pos_right - node_pos_left + 1\n        if not left_sibling:\n            left_sibling = {'lft': parent_pos_left, 'rgt': parent_pos_right, 'is_parent': True}\n        instance.tree_id = parent_tree_id\n        _insert_subtree(table, connection, node_size, node_pos_left, node_pos_right, parent_pos_left, parent_pos_right, subtree, parent_tree_id, parent_level, node_level, left_sibling, table_pk)\n    else:\n        if left_sibling_tree_id or left_sibling_tree_id == 0:\n            tree_id = left_sibling_tree_id + 1\n            connection.execute(table.update(table.c.tree_id > left_sibling_tree_id).values(tree_id=tree_id))\n        else:\n            tree_id = connection.scalar(select([func.max(table.c.tree_id) + 1]))\n        connection.execute(table.update(table_pk.in_(subtree)).values(lft=table.c.lft - node_pos_left + 1, rgt=table.c.rgt - node_pos_left + 1, level=table.c.level - node_level + default_level, tree_id=tree_id))"}
{"i": 497, "got": "def after_flush_postexec(self, session, context):\n    \"\"\"pass\"\"\"\n    instances = self.instances[session]\n    while instances:\n        instance = instances.pop()\n        if instance not in session:\n            continue\n        parent = self.get_parent_value(instance)\n        while parent != NO_VALUE and parent is not None:\n            instances.discard(parent)\n            session.expire(parent, ['left', 'right', 'tree_id', 'level'])\n            parent = self.get_parent_value(parent)\n        session.expire(instance, ['left', 'right', 'tree_id', 'level'])\n        self.expire_session_for_children(session, instance)"}
{"i": 498, "got": "def is_ancestor_of(self, other, inclusive=False):\n    \"\"\"pass\"\"\"\n    if inclusive:\n        return (self.tree_id == other.tree_id) & (self.left <= other.left) & (other.right <= self.right)\n    else:\n        return (self.tree_id == other.tree_id) & (self.left < other.left) & (other.right < self.right)"}
{"i": 499, "got": "def move_inside(self, parent_id):\n    \"\"\"pass\"\"\"\n    session = Session.object_session(self)\n    self.parent_id = parent_id\n    self.mptt_move_inside = parent_id\n    session.add(self)"}
{"i": 500, "got": "def move_after(self, node_id):\n    \"\"\"pass\"\"\"\n    session = Session.object_session(self)\n    self.parent_id = self.parent_id\n    self.mptt_move_after = node_id\n    session.add(self)"}
{"i": 501, "got": "def make_request(cls, url, method=None, params=None, basic_auth=None, timeout=600):\n    \"\"\"pass\"\"\"\n    params = {} if params is None else params\n    cls.request_id += 1\n    params = {k: v for k, v in params.items() if v is not None}\n    data = {'method': method, 'params': params, 'jsonrpc': '2.0', 'id': cls.request_id}\n    headers = {'Content-Type': 'application/json-rpc', 'user-agent': 'LBRY python3-api'}\n    request = requests.Request('POST', url, json=data, headers=headers, auth=basic_auth)\n    prepared = request.prepare()\n    try:\n        sesh = requests.Session()\n        response = sesh.send(prepared, timeout=timeout)\n        response_json = response.json()\n        if 'result' in response_json:\n            return (response_json['result'], response)\n        elif 'error' in response_json:\n            raise LBRYUtils.LBRYException('POST Request made to LBRY received an error', response_json, response.status_code, prepared)\n    except requests.HTTPError as HE:\n        print(HE)\n        return (None, None)\n    except requests.RequestException as RE:\n        print(RE)\n        print('Printing Request Created:\\n')\n        LBRYUtils.print_request(prepared)\n        return (None, None)"}
{"i": 502, "got": "def adjust_status(info: dict) -> dict:\n    \"\"\"pass\"\"\"\n    modified_info = deepcopy(info)\n    modified_info.update({'level': get_nearest_by_numeric_key(STATUS_MAP, int(info['level'])), 'level2': STATUS_MAP[99] if info['level2'] is None else get_nearest_by_numeric_key(STATUS_MAP, int(info['level2']))})\n    return modified_info"}
{"i": 503, "got": "def status_by_coordinates(self, latitude: float, longitude: float) -> dict:\n    \"\"\"pass\"\"\"\n    cdc_data = await self.raw_cdc_data()\n    nearest = await self.nearest_by_coordinates(latitude, longitude)\n    return adjust_status(cdc_data[nearest['state']['name']])"}
{"i": 504, "got": "def status_by_state(self, state: str) -> dict:\n    \"\"\"pass\"\"\"\n    data = await self.raw_cdc_data()\n    try:\n        info = next((v for k, v in data.items() if state in k))\n    except StopIteration:\n        return {}\n    return adjust_status(info)"}
{"i": 505, "got": "def insert(self, **kwargs):\n    \"\"\"pass\"\"\"\n    if self.is_valid:\n        before = self.before_insert()\n        if before:\n            return before\n        try:\n            self._document['_id'] = self.insert_one(self._document)\n            self.after_insert()\n            return self._document\n        except PyMongoException as exc:\n            return PyMongoError(error_message=exc.details.get('errmsg', exc.details.get('err', 'PyMongoError.')), operation='insert', collection=type(self).__name__, document=self._document)\n    else:\n        return self._errors"}
{"i": 506, "got": "def update(self, **kwargs):\n    \"\"\"pass\"\"\"\n    if self.is_valid:\n        if '_id' in self._document:\n            to_update = self.find_one({'_id': self._id})\n            if to_update:\n                before = self.before_update(old=to_update)\n                return before if before else self.replace_one({'_id': self._id}, self._document), self.after_update(old=to_update), self._document\n            else:\n                return DocumentNotFoundError(type(self).__name__, self._id)\n        else:\n            return UnidentifiedDocumentError(type(self).__name__, self._document)\n    else:\n        return self._errors"}
{"i": 507, "got": "def delete(self, **kwargs):\n    \"\"\"pass\"\"\"\n    if self.is_valid:\n        if '_id' in self._document:\n            to_delete = self.find_one({'_id': self._id})\n            if to_delete:\n                before = self.before_delete()\n                return before if before else PyMongoError(error_message=exc.details.get('errmsg', exc.details.get('err', 'PyMongoError.')), operation='delete', collection=type(self).__name__, document=self._document)\n            else:\n                return DocumentNotFoundError(type(self).__name__, self._id)\n        else:\n            return UnidentifiedDocumentError(type(self).__name__, self._document)"}
{"i": 508, "got": "def find_one(cls, filter=None, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    return cls.collection.find_one(filter, *args, **kwargs)"}
{"i": 509, "got": "def find(cls, *args, **kwargs):\n    \"\"\"pass\"\"\"\n    return list(cls.collection.find(*args, **kwargs))"}
{"i": 510, "got": "def aggregate(cls, pipeline=None, **kwargs):\n    \"\"\"pass\"\"\"\n    return list(cls.collection.aggregate(pipeline or [], **kwargs))"}
{"i": 511, "got": "def in_file(self, fn: str) -> Iterator[Statement]:\n    \"\"\"pass\"\"\"\n    yield from self.__file_to_statements.get(fn, [])"}
{"i": 512, "got": "def at_line(self, line: FileLine) -> Iterator[Statement]:\n    \"\"\"pass\"\"\"\n    num = line.num\n    for stmt in self.in_file(line.filename):\n        if stmt.location.start.line == num:\n            yield stmt"}
{"i": 513, "got": "def wrap(text, width=70, **kwargs):\n    \"\"\"pass\"\"\"\n    w = ParagraphWrapper(width=width, **kwargs)\n    return w.wrap(text)"}
{"i": 514, "got": "def fill(text, width=70, **kwargs):\n    \"\"\"pass\"\"\"\n    w = ParagraphWrapper(width=width, **kwargs)\n    return w.fill(text)"}
{"i": 515, "got": "def split(cls, text):\n    \"\"\"pass\"\"\"\n    result = [line.strip('\\n') for line in cls.parasep_re.split(text)]\n    if result == ['', '']:\n        result = ['']\n    return result"}
{"i": 516, "got": "def wrap(self, text):\n    \"\"\"pass\"\"\"\n    lines = []\n    linewrap = partial(textwrap.TextWrapper.wrap, self)\n    for para in self.split(text):\n        lines.extend(linewrap(para))\n        lines.append('')\n    lines = lines[:-1]\n    return lines"}
{"i": 517, "got": "def getSenderNumberMgtURL(self, CorpNum, UserID):\n    \"\"\"pass\"\"\"\n    result = self._httpget('/FAX/?TG=SENDER', CorpNum, UserID)\n    return result.url"}
{"i": 518, "got": "def getUnitCost(self, CorpNum):\n    \"\"\"pass\"\"\"\n    result = self._httpget('/FAX/UnitCost', CorpNum)\n    return int(result.unitCost)"}
{"i": 519, "got": "def getFaxResult(self, CorpNum, ReceiptNum, UserID=None):\n    \"\"\"pass\"\"\"\n    if ReceiptNum == None or len(ReceiptNum) != 18:\n        raise PopbillException(-99999999, '\uc811\uc218\ubc88\ud638\uac00 \uc62c\ubc14\ub974\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.')\n    return self._httpget('/FAX/' + ReceiptNum, CorpNum, UserID)"}
{"i": 520, "got": "def getFaxResultRN(self, CorpNum, RequestNum, UserID=None):\n    \"\"\"pass\"\"\"\n    if RequestNum == None or RequestNum == '':\n        raise PopbillException(-99999999, '\uc694\uccad\ubc88\ud638\uac00 \uc785\ub825\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.')\n    return self._httpget('/FAX/Get/' + RequestNum, CorpNum, UserID)"}
{"i": 521, "got": "def sendFax(self, CorpNum, SenderNum, ReceiverNum, ReceiverName=None, FilePath=None, ReserveDT=None, UserID=False, SenderName=None, adsYN=None, title=None, RequestNum=None):\n    \"\"\"pass\"\"\"\n    receivers = []\n    receivers.append(FaxReceiver(receiveNum=ReceiverNum, receiveName=ReceiverName))\n    return self.sendFax_multi(CorpNum, SenderNum, receivers, FilePath, ReserveDT, UserID, SenderName, adsYN, title, RequestNum)"}
{"i": 522, "got": "def sendFax_multi(self, CorpNum, SenderNum=None, Receiver=None, FilePath=None, ReserveDT=False, UserID=None, SenderName=None, adsYN=None, title=None, RequestNum=None):\n    \"\"\"pass\"\"\"\n    if SenderNum == None or SenderNum == '':\n        raise PopbillException(-99999999, '\ubc1c\uc2e0\uc790 \ubc88\ud638\uac00 \uc785\ub825\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.')\n    elif Receiver == None:\n        raise PopbillException(-99999999, '\uc218\uc2e0\uc790 \uc815\ubcf4\uac00 \uc785\ub825\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.')\n    if not type(Receiver) is str and (not type(Receiver) is FaxReceiver) and (not type(Receiver) is list):\n        raise PopbillException(-99999999, \"'Receiver' argument type error. 'FaxReceiver' or List of 'FaxReceiver'.\")\n    elif FilePath == None:\n        raise PopbillException(-99999999, '\ubc1c\uc2e0 \ud30c\uc77c\uacbd\ub85c\uac00 \uc785\ub825\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.')\n    if not type(FilePath) is str and (not type(FilePath) is list):\n        raise PopbillException(-99999999, '\ubc1c\uc2e0 \ud30c\uc77c\uc740 \ud30c\uc77c\uacbd\ub85c \ub610\ub294 \uacbd\ub85c\ubaa9\ub85d\ub9cc \uc785\ub825 \uac00\ub2a5\ud569\ub2c8\ub2e4.')\n    elif type(FilePath) is list:\n        if len(FilePath) < 1 or len(FilePath) > 20:\n            raise PopbillException(-99999999, '\ud30c\uc77c\uc740 1\uac1c \uc774\uc0c1, 20\uac1c \uae4c\uc9c0 \uc804\uc1a1 \uac00\ub2a5\ud569\ub2c8\ub2e4.')\n    req = {'snd': SenderNum, 'sndnm': SenderName, 'fCnt': 1 if type(FilePath) is str else len(FilePath), 'rcvs': [], 'sndDT': None}\n    if type(Receiver) is str:\n        Receiver = FaxReceiver(receiveNum=Receiver)\n    if type(Receiver) is FaxReceiver:\n        Receiver = [Receiver]\n    if adsYN:\n        req['adsYN'] = True\n    for r in Receiver:\n        req['rcvs'].append({'rcv': r.receiveNum, 'rcvnm': r.receiveName})\n    if ReserveDT != None:\n        req['sndDT'] = ReserveDT\n    if title != None:\n        req['title'] = title\n    if RequestNum != None:\n        req['requestNum'] = RequestNum\n    postData = self._stringtify(req)\n    if type(FilePath) is str:\n        FilePath = [FilePath]\n    files = []\n    for filePath in FilePath:\n        with open(filePath, 'rb') as f:\n            files.append(File(fieldName='file', fileName=f.name, fileData=f.read()))\n    result = self._httppost_files('/FAX', postData, files, CorpNum, UserID)\n    return result.receiptNum"}
{"i": 523, "got": "def model_node(**kwargs):\n    \"\"\"pass\"\"\"\n    kwargs.setdefault('default', {})\n\n    def decorator(model):\n        return types.ModelType(model, **kwargs)\n    return decorator"}
{"i": 524, "got": "def status_by_coordinates(self, latitude: float, longitude: float) -> dict:\n    \"\"\"pass\"\"\"\n    return await self.nearest_by_coordinates(latitude, longitude)"}
{"i": 525, "got": "def status_by_zip(self, zip_code: str) -> dict:\n    \"\"\"pass\"\"\"\n    try:\n        location = next((d for d in self.user_reports() if d['zip'] == zip_code))\n    except StopIteration:\n        return {}\n    return await self.status_by_coordinates(float(location['latitude']), float(location['longitude']))"}
{"i": 526, "got": "def print_request(request):\n    \"\"\"pass\"\"\"\n    print('{}\\n{}\\n{}\\n\\n{}'.format('-----------START-----------', request.method + ' ', request.url, '\\n'.join(('{}: {}'.format(k, v) for k, v in request.headers.items()))))"}
{"i": 527, "got": "def filter_validate_schemas(get_response, params):\n    \"\"\"pass\"\"\"\n    request_schema = params.get('request_schema')\n    if request_schema is None:\n        return get_response\n\n    def _convert_params(schema, data):\n        for sc in schema.fields.values():\n            name = sc.serialized_name or sc.name\n            val = data.getlist(name)\n            if val is not None:\n                if len(val) == 1 and (not isinstance(sc, ListType)):\n                    val = val[0]\n                data[name] = val\n\n    def decorated_filter(request, *args, **kwargs):\n        data = {'headers': CIDict(request.headers), 'path': request.app.router.get(request)[2], 'params': RequestParameters(request.args), 'body': {}}\n        if request.body:\n            if request.form:\n                data['body'] = RequestParameters(request.form)\n            else:\n                data['body'] = deepcopy(request.json)\n        if hasattr(request_schema, 'body') and request.form:\n            _convert_params(request_schema.body, data['body'])\n        if hasattr(request_schema, 'params') and data['params']:\n            _convert_params(request_schema.params, data['params'])\n        try:\n            model = request_schema(data, strict=False, validate=False)\n            model.validate()\n            request.validated = model.to_native()\n        except BaseError as e:\n            raise ValidationErrors(e.to_primitive())\n        return await get_response(request, *args, **kwargs)\n    return decorated_filter"}
{"i": 528, "got": "def filter_validate_response(get_response, params):\n    \"\"\"pass\"\"\"\n    schema = params.get('response_schema')\n\n    def decorated_filter(request, *args, **kwargs):\n        response = await get_response(request, *args, **kwargs)\n        if isinstance(response, HTTPResponse) and (not isinstance(response, Response)):\n            return response\n        if not isinstance(response, Response):\n            raise TypeError('response is not an instance of rafter.http.Response.')\n        if schema:\n            data = {'body': response.data, 'headers': response.headers}\n            try:\n                model = schema(data, strict=False, validate=False)\n                model.validate()\n                result = model.to_primitive()\n                response.body = result.get('body', None)\n                response.headers.update(result.get('headers', {}))\n            except BaseError as e:\n                log.exception(e)\n                abort(500, 'Wrong data output')\n        return response\n    return decorated_filter"}
{"i": 529, "got": "def _write_int(fname, data, append=True):\n    \"\"\"pass\"\"\"\n    data_ex = pexdoc.exh.addex(ValueError, 'There is no data to save to file')\n    fos_ex = pexdoc.exh.addex(OSError, 'File *[fname]* could not be created: *[reason]*')\n    data_ex(len(data) == 0 or (len(data) == 1 and len(data[0]) == 0))\n    try:\n        pmisc.make_dir(fname)\n        mode = 'w' if append is False else 'a'\n        if sys.hexversion < 50331648:\n            with open(fname, mode) as file_handle:\n                csv.writer(file_handle, delimiter=',').writerows(data)\n        else:\n            with open(fname, mode, newline='') as file_handle:\n                csv.writer(file_handle, delimiter=',').writerows(data)\n    except (IOError, OSError) as eobj:\n        fos_ex(True, _MF('fname', fname, 'reason', eobj.strerror))"}
{"i": 530, "got": "def revdocs2reverts(rev_docs, radius=defaults.RADIUS, use_sha1=False, resort=False, verbose=False):\n    \"\"\"pass\"\"\"\n    page_rev_docs = groupby(rev_docs, lambda rd: rd.get('page'))\n    for page_doc, rev_docs in page_rev_docs:\n        if verbose:\n            sys.stderr.write(page_doc.get('title') + ': ')\n            sys.stderr.flush()\n        if resort:\n            if verbose:\n                sys.stderr.write('(sorting) ')\n                sys.stderr.flush()\n            rev_docs = sorted(rev_docs, key=lambda r: (r.get('timestamp'), r.get('id')))\n        detector = Detector(radius=radius)\n        for rev_doc in rev_docs:\n            if not use_sha1 and 'text' not in rev_doc:\n                logger.warn(\"Skipping {0}: 'text' field not found in {0}\".format(rev_doc['id'], rev_doc))\n                continue\n            if use_sha1:\n                checksum = rev_doc.get('sha1') or DummyChecksum()\n            elif 'text' in rev_doc:\n                text_bytes = bytes(rev_doc['text'], 'utf8', 'replace')\n                checksum = hashlib.sha1(text_bytes).digest()\n            revert = detector.process(checksum, rev_doc)\n            if revert:\n                yield revert.to_json()\n                if verbose:\n                    sys.stderr.write('r')\n                    sys.stderr.flush()\n            elif verbose:\n                sys.stderr.write('.')\n                sys.stderr.flush()\n        if verbose:\n            sys.stderr.write('\\n')\n            sys.stderr.flush()"}
{"i": 531, "got": "def dsort(fname, order, has_header=True, frow=0, ofname=None):\n    \"\"\"pass\"\"\"\n    ofname = fname if ofname is None else ofname\n    obj = CsvFile(fname=fname, has_header=has_header, frow=frow)\n    obj.dsort(order)\n    obj.write(fname=ofname, header=has_header, append=False)"}
{"i": 532, "got": "def main() -> None:\n    \"\"\"pass\"\"\"\n    logging.basicConfig(level=logging.INFO)\n    with ClientSession() as websession:\n        try:\n            client = Client(websession)\n            user_coord_resp = await client.user_reports.status_by_coordinates(LATITUDE, LONGITUDE)\n            _LOGGER.info('User data by latitude/longitude (%s, %s): %s', LATITUDE, LONGITUDE, user_coord_resp)\n            user_zip_resp = await client.user_reports.status_by_zip(ZIP_CODE)\n            _LOGGER.info('User data by ZIP code (%s): %s', ZIP_CODE, user_zip_resp)\n            cdc_coord_resp = await client.cdc_reports.status_by_coordinates(LATITUDE, LONGITUDE)\n            _LOGGER.info('CDC data by latitude/longitude (%s, %s): %s', LATITUDE, LONGITUDE, cdc_coord_resp)\n            cdc_state_resp = await client.cdc_reports.status_by_state(STATE)\n            _LOGGER.info('CDC data by state name (%s): %s', STATE, cdc_state_resp)\n        except FluNearYouError as err:\n            print(err)"}
{"i": 533, "got": "def call(cls, method, params=None, timeout=600):\n    \"\"\"pass\"\"\"\n    params = [] if params is None else params\n    return cls.make_request(SERVER_ADDRESS, method, params, timeout=timeout)"}
{"i": 534, "got": "def concatenate(fname1, fname2, dfilter1=None, dfilter2=None, has_header1=True, has_header2=True, frow1=0, frow2=0, ofname=None, ocols=None):\n    \"\"\"pass\"\"\"\n    iro = pexdoc.exh.addex(RuntimeError, 'Files have different number of columns')\n    iom = pexdoc.exh.addex(RuntimeError, 'Number of columns in data files and output columns are different')\n    obj1 = CsvFile(fname=fname1, dfilter=dfilter1, has_header=has_header1, frow=frow1)\n    obj2 = CsvFile(fname=fname2, dfilter=dfilter2, has_header=has_header2, frow=frow2)\n    ofname = fname1 if ofname is None else ofname\n    if ocols is None:\n        if has_header1:\n            ocols = [obj1.header()] if obj1.cfilter is None else [obj1.cfilter]\n    elif ocols is None:\n        if has_header2:\n            ocols = [obj2.header()] if obj2.cfilter is None else [obj2.cfilter]\n    else:\n        if iom(obj1.cfilter is not None and len(obj1.cfilter) != len(ocols)):\n            ocols = [ocols]\n    iro(_C(obj1.cfilter, obj2.cfilter) and (len(obj1.cfilter) != len(obj2.cfilter)))\n    data = ocols + obj1.data(filtered=True) + obj2.data(filtered=True)\n    write(fname=ofname, data=data, append=False)"}
{"i": 535, "got": "def resource(self, uri, methods=frozenset({'GET'}), host=None, strict_slashes=None, stream=False, version=None, name=None, **kwargs):\n    \"\"\"pass\"\"\"\n    if strict_slashes is None:\n        strict_slashes = self.strict_slashes\n\n    def decorator(handler):\n        self.resources.append((FutureRoute(handler, uri, methods, host, strict_slashes, stream, version, name), kwargs))\n        return handler\n    return decorator"}
{"i": 536, "got": "def add_resource(self, handler, uri, methods=frozenset({'GET'}), host=None, strict_slashes=None, version=None, name=None, **kwargs):\n    \"\"\"pass\"\"\"\n    self.resource(uri=uri, methods=methods, host=host, strict_slashes=strict_slashes, version=version, name=name, **kwargs)(handler)"}
{"i": 537, "got": "def in_file(self, fn: str) -> Iterator[InsertionPoint]:\n    \"\"\"pass\"\"\"\n    logger.debug('finding insertion points in file: %s', fn)\n    yield from self.__file_insertions.get(fn, [])"}
{"i": 538, "got": "def at_line(self, line: FileLine) -> Iterator[InsertionPoint]:\n    \"\"\"pass\"\"\"\n    logger.debug('finding insertion points at line: %s', str(line))\n    filename = line.filename\n    line_num = line.num\n    for ins in self.in_file(filename):\n        if line_num == ins.location.line:\n            logger.debug('found insertion point at line [%s]: %s', str(line), ins)\n            yield ins"}
{"i": 539, "got": "def _doAtomicFileCreation(filePath):\n    \"\"\"pass\"\"\"\n    try:\n        _os.close(_os.open(filePath, _os.O_CREAT | _os.O_EXCL))\n        return True\n    except OSError as e:\n        if e.errno == _errno.EEXIST:\n            return False\n        else:\n            raise e"}
{"i": 540, "got": "def findNextFile(folder='.', prefix=None, suffix=None, fnameGen=None, base=0, maxattempts=10):\n    \"\"\"pass\"\"\"\n    expFolder = _os.path.expanduser(_os.path.expandvars(folder))\n    return _findNextFile(expFolder, prefix, suffix, fnameGen, base, maxattempts, 0)"}
{"i": 541, "got": "def _run(passedArgs=None, stderr=None, stdout=None, exitFn=None):\n    \"\"\"pass\"\"\"\n    description = 'Finds the next available file-name in a sequence.\\n\\n    This program will create a file of zero size and will output the path to it\\n    on STDOUT. No files which exist will be altered in this operation and\\n    concurrent invocations of this program will return separate files. In case\\n    of conflict, this program will attempt to generate a new file name up to\\n    \\'maxattempts\\' number of times before failing. (See --max-attempts)\\n\\n    The sequence will start from the base argument (See --base, default: 0).\\n\\n    This program will look for the next file in the sequence ignoring any gaps.\\n    Hence, if the files \"a.0.txt\" and \"a.3.txt\" exist, then the next file\\n    returned will be \"a.4.txt\" when called with prefix=\"a.\" and suffix=\".txt\".\\n\\n    Returns:\\n        Path of the file which follows the provided pattern and can be opened\\n        for writing.\\n\\n        Otherwise, it prints an error (wrong path, drive full, illegal\\n        character in filename, etc.) to stderr and exits with a non-zero error\\n        code.\\n    \"\"\"\n    argParser = _argparse.ArgumentParser(description=description, formatter_class=_argparse.RawTextHelpFormatter)\n    argParser.add_argument('prefix', help='Prefix for the sequence of files.')\n    argParser.add_argument('suffix', help='Suffix for the sequence of files.', nargs='?', default='')\n    argParser.add_argument('folder', help='The folder where the file will be created.', nargs='?', default=_os.getcwd())\n    argParser.add_argument('-m', '--max-attempts', help='Number of attempts to make before giving up.', default=10)\n    argParser.add_argument('-b', '--base', help='From where to start counting (default: 0).', default=0)\n    passedArgs = passedArgs if passedArgs is not None else _sys.argv[1:]\n    args = argParser.parse_args(passedArgs)\n    stdout = _sys.stdout if stdout is None else stdout\n    stderr = _sys.stderr if stderr is None else stderr\n    try:\n        nextFile = findNextFile(args.folder, prefix=args.prefix, suffix=args.suffix, maxattempts=args.max_attempts, base=args.base)\n        stdout.write(nextFile + '\\n')\n    except OSError as e:\n        stderr.write(_os.strerror(e.errno) + '\\n')\n        _sys.exit(e.errno)"}
{"i": 542, "got": "def _errstr(value):\n    \"\"\"pass\"\"\"\n    value = str(value)\n    if len(value) > MAX_ERROR_STR_LEN:\n        return value[:MAX_ERROR_STR_LEN] + '...'\n    else:\n        return value"}
{"i": 543, "got": "def _getStrippedValue(value, strip):\n    \"\"\"pass\"\"\"\n    if strip is None:\n        value = value.strip()\n    elif isinstance(strip, str):\n        value = value.strip(strip)\n    elif strip is False:\n        pass\n    return value"}
{"i": 544, "got": "def _raiseValidationException(standardExcMsg, customExcMsg=None):\n    \"\"\"pass\"\"\"\n    if customExcMsg is None:\n        raise ValidationException(str(standardExcMsg))\n    else:\n        raise ValidationException(str(customExcMsg))"}
{"i": 545, "got": "def _prevalidationCheck(value, blank, strip, allowlistRegexes, blocklistRegexes, excMsg=None):\n    \"\"\"pass\"\"\"\n    value = str(value)\n    value = _getStrippedValue(value, strip)\n    if not blank and value == '':\n        _raiseValidationException(_('Blank values are not allowed.'), excMsg)\n    elif blank and value == '':\n        return (True, value)\n    if allowlistRegexes is not None:\n        for regex in allowlistRegexes:\n            if isinstance(regex, re.Pattern):\n                if regex.search(value, re.IGNORECASE) is not None:\n                    return (True, value)\n            else:\n                if re.search(regex, value, re.IGNORECASE) is not None:\n                    return (True, value)\n    elif blocklistRegexes is not None:\n        for blocklistRegexItem in blocklistRegexes:\n            if isinstance(blocklistRegexItem, str):\n                regex, response = (blocklistRegexItem, DEFAULT_BLOCKLIST_RESPONSE)\n            else:\n                regex, response = blocklistRegexItem\n            if isinstance(regex, re.Pattern) and regex.search(value, re.IGNORECASE) is not None:\n                _raiseValidationException(response, excMsg)\n            elif re.search(regex, value, re.IGNORECASE) is not None:\n                _raiseValidationException(response, excMsg)\n    return (False, value)"}
{"i": 546, "got": "def _validateGenericParameters(blank, strip, allowlistRegexes, blocklistRegexes):\n    \"\"\"pass\"\"\"\n    if not isinstance(blank, bool):\n        raise PySimpleValidateException('blank argument must be a bool')\n    if not isinstance(strip, (bool, str, type(None))):\n        raise PySimpleValidateException('strip argument must be a bool, None, or str')\n    if allowlistRegexes is None:\n        allowlistRegexes = []\n    try:\n        len(allowlistRegexes)\n    except:\n        raise PySimpleValidateException('allowlistRegexes must be a sequence of regex_strs')\n    for response in allowlistRegexes:\n        if not isinstance(response[0], str):\n            raise PySimpleValidateException('allowlistRegexes must be a sequence of regex_strs')\n    if blocklistRegexes is None:\n        blocklistRegexes = []\n    try:\n        len(blocklistRegexes)\n    except:\n        raise PySimpleValidateException('blocklistRegexes must be a sequence of (regex_str, str) tuples or regex_strs')\n    for response in blocklistRegexes:\n        if not isinstance(response, str):\n            if len(response) != 2:\n                raise PySimpleValidateException('blocklistRegexes must be a sequence of (regex_str, str) tuples or regex_strs')\n            if not (isinstance(response[0], str) and isinstance(response[1], str)):\n                raise PySimpleValidateException('blocklistRegexes must be a sequence of (regex_str, str) tuples or regex_strs')"}
{"i": 547, "got": "def _validateParamsFor_validateNum(min=None, max=None, lessThan=None, greaterThan=None):\n    \"\"\"pass\"\"\"\n    if min is not None and greaterThan is not None:\n        raise PySimpleValidateException('only one argument for min or greaterThan can be passed, not both')\n    elif max is not None and lessThan is not None:\n        raise PySimpleValidateException('only one argument for max or lessThan can be passed, not both')\n    if min is not None and max is not None and (min > max):\n        raise PySimpleValidateException('the min argument must be less than or equal to the max argument')\n    elif min is not None and lessThan is not None and (min >= lessThan):\n        raise PySimpleValidateException('the min argument must be less than the lessThan argument')\n    elif max is not None and greaterThan is not None and (max <= greaterThan):\n        raise PySimpleValidateException('the max argument must be greater than the greaterThan argument')\n    for name, val in [('min', min), ('max', max), ('lessThan', lessThan), ('greaterThan', greaterThan)]:\n        if not isinstance(val, (int, float, type(None))):\n            raise PySimpleValidateException(name + ' argument must be int, float, or NoneType')"}
{"i": 548, "got": "def filter_transform_response(get_response, params):\n    \"\"\"pass\"\"\"\n\n    async def decorated_filter(request, *args, **kwargs):\n        response = await get_response(request, *args, **kwargs)\n        if isinstance(response, HTTPResponse) and (not isinstance(response, Response)):\n            return response\n        if not isinstance(response, Response):\n            response = Response(response)\n        return response\n    return decorated_filter"}
{"i": 549, "got": "def initialize(self, maxsize, history=None):\n    \"\"\"pass\"\"\"\n    super().__init__()\n    self.maxsize = int(maxsize)\n    self.history = deque(maxlen=self.maxsize)\n    if history is not None:\n        for key, value in history:\n            self.insert(key, value)"}
{"i": 550, "got": "def insert(self, key, value):\n    \"\"\"pass\"\"\"\n    if len(self.history) == self.maxsize:\n        expectorate = self.history[0]\n    else:\n        expectorate = None\n    self.history.append((key, value))\n    if key in self:\n        super().__getitem__(key).append(value)\n    else:\n        super().__setitem__(key, [value])\n    if expectorate is not None:\n        old_key, old_value = expectorate\n        super().__getitem__(old_key).pop(0)\n        if len(super().__getitem__(old_key)) == 0:\n            super().__delitem__(old_key)\n        return (old_key, old_value)"}
{"i": 551, "got": "def up_to(self, key):\n    \"\"\"pass\"\"\"\n    for okey, ovalue in reversed(self.history):\n        if okey == key:\n            break\n        yield ovalue"}
{"i": 552, "got": "def check(session, rev_id, page_id=None, radius=defaults.RADIUS, before=None, window=None, rvprop=None):\n    \"\"\"pass\"\"\"\n    rev_id = int(rev_id)\n    radius = int(radius)\n    if radius < 1:\n        raise TypeError('invalid radius.  Expected a positive integer.')\n    page_id = int(page_id) if page_id is not None else None\n    before = Timestamp(before) if before is not None else None\n    rvprop = set(rvprop) if rvprop is not None else set()\n    if page_id is None:\n        page_id = get_page_id(session, rev_id)\n    current_and_past_revs = list(n_edits_before(session, rev_id, page_id, radius + 1, {'sha1', 'timestamp', 'ids'} | rvprop))\n    if len(current_and_past_revs) < 1:\n        raise KeyError('Revision {0} not found in page {1}.'.format(rev_id, page_id))\n    current_rev, past_revs = (current_and_past_revs[-1], current_and_past_revs[:-1])\n    if window is not None and before is None:\n        before = Timestamp(current_rev['timestamp']) + window\n    future_revs = list(n_edits_after(session, rev_id + 1, page_id, radius, {before}, rvprop))\n    return build_revert_tuple(rev_id, past_revs, current_rev, future_revs, radius)"}
{"i": 553, "got": "def check_deleted(session, rev_id, title=None, timestamp=defaults.RADIUS, radius=None, before=None, window=None, rvprop=None):\n    \"\"\"pass\"\"\"\n    rev_id = int(rev_id)\n    radius = int(radius)\n    if radius < 1:\n        raise TypeError('invalid radius.  Expected a positive integer.')\n    title = str(title) if title is not None else None\n    before = Timestamp(before) if before is not None else None\n    rvprop = set(rvprop) if rvprop is not None else set()\n    if title is None or timestamp is None:\n        title, timestamp = get_deleted_title_and_timestamp(session, rev_id)\n    current_and_past_revs = list(n_deleted_edits_before(session, rev_id, title, timestamp, radius + 1, {'sha1', 'timestamp', 'ids'} | rvprop))\n    if len(current_and_past_revs) < 1:\n        raise KeyError('Revision {0} not found in page {1}.'.format(rev_id, title))\n    current_rev, past_revs = (current_and_past_revs[-1], current_and_past_revs[:-1])\n    if window is not None and before is None:\n        before = Timestamp(current_rev['timestamp']) + window\n    future_revs = list(n_deleted_edits_after(session, rev_id + 1, title, timestamp, radius, before, {'sha1', 'timestamp', 'ids'} | rvprop))\n    return build_revert_tuple(rev_id, past_revs, current_rev, future_revs, radius)"}
{"i": 554, "got": "def get_commits(repo_dir, old_commit, new_commit, hide_merges=True):\n    \"\"\"pass\"\"\"\n    repo = Repo(repo_dir)\n    commits = repo.iter_commits(rev='{0}..{1}'.format(old_commit, new_commit))\n    if hide_merges:\n        return [x for x in commits if not x.summary.startswith('Merge ')]\n    else:\n        return list(commits)"}
{"i": 555, "got": "def get_commit_url(repo_url):\n    \"\"\"pass\"\"\"\n    if 'github.com' in repo_url:\n        return repo_url[:-4] if repo_url.endswith('.git') else repo_url\n    elif 'git.openstack.org' in repo_url:\n        uri = '/'.join(repo_url.split('/')[-2:])\n        return 'https://github.com/{0}'.format(uri)\n    else:\n        return repo_url"}
{"i": 556, "got": "def get_projects(osa_repo_dir, commit):\n    \"\"\"pass\"\"\"\n    repo = Repo(osa_repo_dir)\n    checkout(repo, commit)\n    yaml_files = glob.glob('{0}/playbooks/defaults/repo_packages/*.yml'.format(osa_repo_dir))\n    yaml_parsed = []\n    for yaml_file in yaml_files:\n        with open(yaml_file, 'r') as f:\n            yaml_parsed.append(yaml.load(f))\n    merged_dicts = {k: v for d in yaml_parsed for k, v in d.items()}\n    return normalize_yaml(merged_dicts)"}
{"i": 557, "got": "def checkout(repo, ref):\n    \"\"\"pass\"\"\"\n    if ref in repo.branches:\n        log.warn('Removing local branch {b} for repo {r}'.format(b=ref, r=repo))\n        repo.head.reset(index=True, working_tree=True)\n        repo.git.checkout(repo.head.commit.hexsha)\n        repo.delete_head(ref, '--force')\n    log.info('Checkout out repo {repo} to ref {ref}'.format(repo=repo, ref=ref))\n    repo.head.reset(index=True, working_tree=True)\n    repo.git.checkout(ref)\n    repo.head.reset(index=True, working_tree=True)\n    sha = repo.head.commit.hexsha\n    log.info('Current SHA for repo {repo} is {sha}'.format(repo=repo, sha=sha))"}
{"i": 558, "got": "def get_roles(osa_repo_dir, commit, role_requirements):\n    \"\"\"pass\"\"\"\n    repo = Repo(osa_repo_dir)\n    checkout(repo, commit)\n    log.info('Looking for file {f} in repo {r}'.format(r=osa_repo_dir, f=role_requirements))\n    filename = '{0}/{1}'.format(osa_repo_dir, role_requirements)\n    with open(filename, 'r') as f:\n        roles_yaml = yaml.load(f)\n    return normalize_yaml(roles_yaml)"}
{"i": 559, "got": "def make_osa_report(repo_dir, old_commit, new_commit, args):\n    \"\"\"pass\"\"\"\n    update_repo(repo_dir, args.osa_repo_url, args.update)\n    validate_commits(repo_dir, [old_commit, new_commit])\n    validate_commit_range(repo_dir, old_commit, new_commit)\n    commits = get_commits(repo_dir, old_commit, new_commit)\n    template_vars = {'args': args, 'repo': 'openstack-ansible', 'commits': commits, 'commit_base_url': get_commit_url(args.osa_repo_url), 'old_sha': old_commit, 'new_sha': new_commit}\n    return render_template('offline-header.j2', template_vars)"}
{"i": 560, "got": "def _homogenize_data_filter(dfilter):\n    \"\"\"pass\"\"\"\n    if isinstance(dfilter, tuple) and len(dfilter) == 1:\n        dfilter = (dfilter[0], None)\n    if dfilter is None or dfilter == (None, None) or dfilter == (None,):\n        dfilter = (None, None)\n    elif isinstance(dfilter, dict):\n        dfilter = (dfilter, None)\n    elif not (isinstance(dfilter, (list, str)) and (not (isinstance(dfilter, bool) and isinstance(dfilter, int)))) or (isinstance(dfilter[0], dict) or (filter is None and isinstance(dfilter[1], dict))):\n        pass\n    else:\n        dfilter = (dfilter[1], dfilter[0])\n    return dfilter"}
{"i": 561, "got": "def _tofloat(obj):\n    \"\"\"pass\"\"\"\n    if 'inf' in obj.lower().strip():\n        return obj\n    try:\n        return int(obj)\n    except ValueError:\n        try:\n            return float(obj)\n        except ValueError:\n            return obj"}
{"i": 562, "got": "def _in_header(self, col):\n    \"\"\"pass\"\"\"\n    if not self._has_header:\n        icol_ex = pexdoc.exh.addex(RuntimeError, 'Invalid column specification')\n    hnf_ex = pexdoc.exh.addex(ValueError, 'Column *[column_identifier]* not found')\n    col_list = [col] if isinstance(col, (str, int)) else col\n    for col in col_list:\n        edata = {'field': 'column_identifier', 'value': col}\n        if not self._has_header:\n            icol_ex(not isinstance(col, int))\n            hnf_ex(col < 0 or col > len(self._header) - 1, edata)\n        else:\n            hnf_ex(isinstance(col, int) and (col < 0 or col > self._data_cols) or (isinstance(col, str) and col.upper() not in self._header_upper), edata)\n    return col_list"}
{"i": 563, "got": "def with_reactor(*dec_args, **dec_kwargs):\n    \"\"\"pass\"\"\"\n    if len(dec_args) == 1 and callable(dec_args[0]) and (not dec_kwargs):\n        callee = dec_args[0]\n        dec_args = ()\n        dec_kwargs = {}\n\n        @functools.wraps(callee)\n        def wrapper(*call_args, **call_kwargs):\n            return _twisted_test_sync(callee, call_args, call_kwargs)\n        return wrapper\n    else:\n\n        def decorator(callee):\n\n            @functools.wraps(callee)\n            def wrapper(*call_args, **call_kwargs):\n                return _twisted_test_sync(callee, call_args, call_kwargs, *dec_args, **dec_kwargs)\n            return wrapper\n        return decorator"}
{"i": 564, "got": "def _ensure_reactor_running():\n    \"\"\"pass\"\"\"\n    if not reactor.running:\n        signal_registrations = []\n\n        def signal_capture(*args, **kwargs):\n            signal_registrations.append((orig_signal, args, kwargs))\n\n        def set_wakeup_fd_capture(*args, **kwargs):\n            signal_registrations.append((orig_set_wakeup_fd, args, kwargs))\n        orig_signal = signal.signal\n        signal.signal = signal_capture\n        orig_set_wakeup_fd = signal.set_wakeup_fd\n        signal.set_wakeup_fd = set_wakeup_fd_capture\n        reactor_thread = threading.Thread(target=reactor.run, name='reactor')\n        reactor_thread.daemon = True\n        reactor_thread.start()\n        while not reactor.running:\n            time.sleep(0.01)\n        time.sleep(0.01)\n        signal.signal = orig_signal\n        signal.set_wakeup_fd = orig_set_wakeup_fd\n        for func, args, kwargs in signal_registrations:\n            func(*args, **kwargs)"}
{"i": 565, "got": "def _timeoutDeferred(deferred, timeout):\n    \"\"\"pass\"\"\"\n    delayedCall = reactor.callLater(timeout, deferred.cancel)\n\n    def gotResult(result):\n        if delayedCall.active():\n            delayedCall.cancel()\n        return result\n    deferred.addBoth(gotResult)"}
{"i": 566, "got": "def _get_json(value):\n    \"\"\"pass\"\"\"\n    if hasattr(value, 'replace'):\n        value = value.replace('\\n', ' ')\n    try:\n        return json.loads(value)\n    except json.JSONDecodeError:\n        if hasattr(value, 'replace'):\n            value = value.replace('\"', '\\\\\"')\n        return json.loads('\"{}\"'.format(value))"}
{"i": 567, "got": "def save_list(key, *values):\n    \"\"\"pass\"\"\"\n    return json.dumps({key: [_get_json(value) for value in values]})"}
{"i": 568, "got": "def save_file(key, file_path, *refs):\n    \"\"\"pass\"\"\"\n    if not os.path.isfile(file_path):\n        return error(\"Output '{}' set to a missing file: '{}'.\".format(key, file_path))\n    result = {key: {'file': file_path}}\n    if refs:\n        missing_refs = [ref for ref in refs if (not os.path.isfile(ref)) and (not os.path.isdir(ref))]\n        if len(missing_refs) > 0:\n            return error(\"Output '{}' set to missing references: '{}'.\".format(key, ', '.join(missing_refs)))\n        result[key]['refs'] = refs\n    return json.dumps(result)"}
{"i": 569, "got": "def save_file_list(key, *files_refs):\n    \"\"\"pass\"\"\"\n    file_list = []\n    for file_refs in files_refs:\n        if ':' in file_refs:\n            try:\n                file_name, refs = file_refs.split(':')\n            except ValueError as e:\n                return error(\"Only one colon ':' allowed in file-refs specification.\")\n        else:\n            file_name, refs = (file_refs, None)\n        if not os.path.isfile(file_name):\n            return error(\"Output '{}' set to a missing file: '{}'.\".format(key, file_name))\n        file_obj = {'file': file_name}\n        if refs:\n            refs = [ref_path.strip() for ref_path in refs.split(',')]\n            missing_refs = [ref for ref in refs if not os.path.isfile(ref) and (not os.path.isdir(ref))]\n            if len(missing_refs) > 0:\n                return error(\"Output '{}' set to missing references: '{}'.\".format(key, ', '.join(missing_refs)))\n            file_obj['refs'] = refs\n        file_list.append(file_obj)\n    return json.dumps({key: file_list})"}
{"i": 570, "got": "def save_dir(key, dir_path, *refs):\n    \"\"\"pass\"\"\"\n    if not os.path.isdir(dir_path):\n        return error(\"Output '{}' set to a missing directory: '{}'.\".format(key, dir_path))\n    result = {key: {'dir': dir_path}}\n    if refs:\n        missing_refs = [ref for ref in refs if (not os.path.isfile(ref)) and (not os.path.isdir(ref))]\n        if len(missing_refs) > 0:\n            return error(\"Output '{}' set to missing references: '{}'.\".format(key, ', '.join(missing_refs)))\n        result[key]['refs'] = refs\n    return json.dumps(result)"}
{"i": 571, "got": "def save_dir_list(key, *dirs_refs):\n    \"\"\"pass\"\"\"\n    dir_list = []\n    for dir_refs in dirs_refs:\n        if ':' in dir_refs:\n            try:\n                dir_path, refs = dir_refs.split(':')\n            except ValueError as e:\n                return error(\"Only one colon ':' allowed in dir-refs specification.\")\n        else:\n            dir_path, refs = (dir_refs, None)\n        if not os.path.isdir(dir_path):\n            return error(\"Output '{}' set to a missing directory: '{}'.\".format(key, dir_path))\n        dir_obj = {'dir': dir_path}\n        if refs:\n            refs = [ref_path.strip() for ref_path in refs.split(',')]\n            missing_refs = [ref for ref in refs if not os.path.isfile(ref) and (not os.path.isdir(ref))]\n            if len(missing_refs) > 0:\n                return error(\"Output '{}' set to missing references: '{}'.\".format(key, ', '.join(missing_refs)))\n            dir_obj['refs'] = refs\n        dir_list.append(dir_obj)\n    return json.dumps({key: dir_list})"}
{"i": 572, "got": "def n_day(date_string):\n    \"\"\"pass\"\"\"\n    today = datetime.date.today()\n    match = re.match('(\\\\d{1,3}|a) days? ago', date_string)\n    groups = match.groups()\n    if groups:\n        decrement = groups[0]\n        if decrement == 'a':\n            decrement = 1\n        return today - datetime.timedelta(days=int(decrement))"}
{"i": 573, "got": "def encloses(self, location: FileLocation) -> Optional[FunctionDesc]:\n    \"\"\"pass\"\"\"\n    for func in self.in_file(location.filename):\n        if location in func.location:\n            return func\n    return None"}
{"i": 574, "got": "def in_file(self, filename: str) -> Iterator[FunctionDesc]:\n    \"\"\"pass\"\"\"\n    yield from self.__filename_to_functions.get(filename, [])"}
{"i": 575, "got": "def parse_config(args):\n    \"\"\"pass\"\"\"\n    config_path = path.expanduser(args.config_file)\n    if not path.exists(config_path):\n        if args.config_file != DEFAULT_JOURNAL_RC:\n            print(\"journal: error: config file '\" + args.config_file + \"' not found\")\n            sys.exit()\n        else:\n            return DEFAULT_JOURNAL\n    config = ConfigParser.SafeConfigParser({'journal': {'default': '__journal'}, '__journal': {'location': DEFAULT_JOURNAL}})\n    config.read(config_path)\n    journal_location = config.get(config.get('journal', 'default'), 'location')\n    if args.journal:\n        journal_location = config.get(args.journal, 'location')\n    return journal_location"}
{"i": 576, "got": "def record_entries(journal_location, entries):\n    \"\"\"pass\"\"\"\n    check_journal_dest(journal_location)\n    current_date = datetime.datetime.today()\n    date_header = current_date.strftime('%a %H:%M:%S %Y-%m-%d') + '\\n'\n    with open(build_journal_path(journal_location, current_date), 'a') as date_file:\n        entry_output = date_header\n        entry_output += '-' + ' '.join(entries) + '\\n'\n        entry_output += '\\n'\n        date_file.write(entry_output)"}
{"i": 577, "got": "def get_entry(journal_location, date):\n    \"\"\"pass\"\"\"\n    if not isinstance(date, datetime.date):\n        return None\n    try:\n        with open(build_journal_path(journal_location, date), 'r') as entry_file:\n            return entry_file.read()\n    except IOError:\n        pass"}
{"i": 578, "got": "def TemplateValidator(value):\n    \"\"\"pass\"\"\"\n    try:\n        Template(value)\n    except Exception as e:\n        raise ValidationError(_('Cannot compile template (%(exception)s)'), params={'exception': e})"}
{"i": 579, "got": "def get_lbry_api_function_docs(url=LBRY_API_RAW_JSON_URL):\n    \"\"\"pass\"\"\"\n    try:\n        docs_page = urlopen(url)\n        contents = docs_page.read().decode('utf-8')\n        return loads(contents)\n    except URLError as UE:\n        print(UE)\n        return []\n    except Exception as E:\n        print(E)\n        return []"}
{"i": 580, "got": "def generate_method_definition(func):\n    \"\"\"pass\"\"\"\n    indent = 4\n    method_definition = ' ' * indent + 'def ' + func['name']\n    params_required = [param for param in func['arguments'] if param['is_required']]\n    params_optional = [param for param in func['arguments'] if not param['is_required']]\n    method_definition += '(self, '\n    for param in params_required:\n        method_definition += param['name']\n        method_definition += ', '\n    for param in params_optional:\n        method_definition += param['name']\n        method_definition += '=None, '\n    method_definition = method_definition.rstrip(', ') + '):\\n'\n    indent += 4\n    method_definition += ' ' * indent\n    method_definition += '\"\"\"' + func['description']\n    method_definition += '\\n\\n' + ' ' * indent\n    for param in params_required + params_optional:\n        method_definition += ':param ' + DTYPE_MAPPING[param['type'].lower()]\n        method_definition += ' ' + param['name'] + ': '\n        method_definition += param['description']\n        method_definition += '\\n' if param['is_required'] else ' (Optional)\\n'\n        method_definition += ' ' * indent\n    open_index = func['returns'].find('(')\n    close_index = func['returns'].find(')', open_index > -1 and open_index or 0)\n    func['returns'] = func['returns'].replace('\\t', '    ')\n    return_string = func['returns'].replace('\\n', '')\n    if open_index < close_index:\n        if func['returns'][open_index + 1:close_index] in DTYPE_MAPPING:\n            method_definition += ':rtype: ' + DTYPE_MAPPING[func['returns'][open_index + 1:close_index]]\n            func['returns'] = func['returns'].replace(func['returns'][open_index:close_index + 1], '')\n            method_definition += '\\n' + ' ' * indent\n    method_definition += ':return: ' + return_string\n    for i in range(0, len(return_string) + 1, 80 - (indent + 2)):\n        method_definition += return_string[i:i + 80 - (indent + 2)] + '\\n' + ' ' * indent\n    method_definition += '\"\"\"\\n' + ' ' * indent\n    params_map = '__params_map = {'\n    params_indent, num_params = (len(params_map), len(params_required) + len(params_optional))\n    method_definition += params_map\n    for i, param in enumerate(params_required + params_optional):\n        method_definition += \"'\" + param['name'] + \"': \" + param['name']\n        if not param['is_required']:\n            method_definition += ' if ' + param['name'] + 'is not None else None'\n        method_definition += ',\\n' + ' ' * (indent + 1) + ' ' * params_indent\n    method_definition += '}\\n\\n' + ' ' * indent\n    method_definition += \"return self.make_request(SERVER_ADDRESS, '\" + func['name'] + \"', \" + params_map.rstrip(' = {') + ', timeout=self.timeout)\\n\\n'\n    return method_definition"}
{"i": 581, "got": "def generate_lbryd_wrapper(url=LBRY_API_RAW_JSON_URL, read_file=__LBRYD_BASE_FPATH__, write_file=LBRYD_FPATH):\n    \"\"\"pass\"\"\"\n    functions = get_lbry_api_function_docs(url)\n    with open(write_file, 'w') as lbry_file:\n        lbry_file.write('# This file was generated at build time using the generator function\\n')\n        lbry_file.write('# You may edit but do so with caution\\n')\n        with open(read_file, 'r') as template:\n            header = template.read()\n        lbry_file.write(header)\n        for func in functions:\n            method_definition = generate_method_definition(func)\n            lbry_file.write(method_definition)\n    try:\n        from yapf.yapflib.yapf_api import FormatFile\n        FormatFile(write_file, in_place=True)\n    except ImportError as IE:\n        print('[Warning]: yapf is not installed, so the generated code will not follow an easy-to-read standard')\n        print(IE)"}
{"i": 582, "got": "def get(self, style):\n    \"\"\"pass\"\"\"\n    level = len(self.stack) - 1\n    while level >= 0:\n        if style in self.stack[level]:\n            return self.stack[level][style]\n        else:\n            level = level - 1\n    return None"}
{"i": 583, "got": "def enforce_type(self, attr, val):\n    \"\"\"pass\"\"\"\n    if not attr in self.types:\n        return utfstr(val)\n    elif self.types[attr] == 'int':\n        return int(float(val))\n    elif self.types[attr] == 'float':\n        return float(val)\n    else:\n        return utfstr(val)"}
{"i": 584, "got": "def to_escpos(self):\n    \"\"\"pass\"\"\"\n    cmd = ''\n    ordered_cmds = self.cmds.keys()\n    ordered_cmds.sort(lambda x, y: cmp(self.cmds[x]['_order'], self.cmds[y]['_order']))\n    for style in ordered_cmds:\n        cmd += self.cmds[style][self.get(style)]\n    return cmd"}
{"i": 585, "got": "def start_inline(self, stylestack=None):\n    \"\"\"pass\"\"\"\n    self.stack.append('inline')\n    if self.dirty:\n        self.escpos._raw(' ')\n    if stylestack:\n        self.style(stylestack)"}
{"i": 586, "got": "def start_block(self, stylestack=None):\n    \"\"\"pass\"\"\"\n    if self.dirty:\n        self.escpos._raw('\\n')\n        self.dirty = False\n    self.stack.append('block')\n    if stylestack:\n        self.style(stylestack)"}
{"i": 587, "got": "def end_entity(self):\n    \"\"\"pass\"\"\"\n    if self.stack[-1] == 'block' and self.dirty:\n        self.escpos._raw('\\n')\n        self.dirty = False\n    if len(self.stack) > 1:\n        self.stack = self.stack[:-1]"}
{"i": 588, "got": "def _pinyin_generator(chars, format):\n    \"\"\"pass\"\"\"\n    for char in chars:\n        key = '%X' % ord(char)\n        pinyin = pinyin_dict.get(key, char)\n        tone = pinyin_tone.get(key, 0)\n        if tone == 0 or format == 'strip':\n            pass\n        elif format == 'numerical':\n            pinyin += str(tone)\n        elif format == 'diacritical':\n            vowels = itertools.chain((c for c in pinyin if c in 'aeo'), (c for c in pinyin if c in 'iuv'))\n            vowel = pinyin.index(next(vowels)) + 1\n            pinyin = pinyin[:vowel] + tonemarks[tone] + pinyin[vowel:]\n        else:\n            error = 'Format must be one of: numerical/diacritical/strip'\n            raise ValueError(error)\n        yield unicodedata.normalize('NFC', pinyin)"}
{"i": 589, "got": "def get(s, delimiter='', format='diacritical'):\n    \"\"\"pass\"\"\"\n    return delimiter.join(_pinyin_generator(u(s), format=format))"}
{"i": 590, "got": "def get_initial(s, delimiter=' '):\n    \"\"\"pass\"\"\"\n    initials = (p[0] for p in _pinyin_generator(u(s), format='strip'))\n    return delimiter.join(initials)"}
{"i": 591, "got": "def _add_to_tree(tree, word, meaning):\n    \"\"\"pass\"\"\"\n    if len(word) == 0:\n        tree[''] = meaning\n    else:\n        _add_to_tree(tree[word[0]], word[1:], meaning)"}
{"i": 592, "got": "def init():\n    \"\"\"pass\"\"\"\n    global dictionaries, trees\n    dictionaries = {'traditional': {}, 'simplified': {}}\n    trees = {'traditional': Tree(), 'simplified': Tree()}\n    lines = gzip.open(os.path.join(os.path.dirname(__file__), 'cedict.txt.gz'), mode='rt', encoding='utf-8')\n    exp = re.compile('^([^ ]+) ([^ ]+) \\\\[(.*)\\\\] /(.+)/')\n    parsed_lines = (exp.match(line).groups() for line in lines if line[0] != '#')\n    for traditional, simplified, pinyin, meaning in parsed_lines:\n        meaning = meaning.split('/')\n        dictionaries['traditional'][traditional] = meaning\n        dictionaries['simplified'][simplified] = meaning\n        _add_to_tree(trees['traditional'], traditional, meaning)\n        _add_to_tree(trees['simplified'], simplified, meaning)"}
{"i": 593, "got": "def translate_word(word, dictionary=['simplified']):\n    \"\"\"pass\"\"\"\n    global dictionaries\n    if not dictionaries:\n        init()\n    for d in dictionary:\n        if word in dictionaries[d]:\n            return dictionaries[d][word]"}
{"i": 594, "got": "def get_status_key(self, instance):\n    \"\"\"pass\"\"\"\n    key_id = 'inst_%s' % id(instance) if instance.pk is None else instance.pk\n    return '%s.%s-%s-%s' % (instance._meta.app_label, get_model_name(instance), key_id, self.field.name)"}
{"i": 595, "got": "def get_status(self, instance):\n    \"\"\"pass\"\"\"\n    status_key, status = self._get_status(instance)\n    if status['state'] in ['complete', 'error']:\n        cache.delete(status_key)\n    return status"}
{"i": 596, "got": "def set_status(self, instance, status):\n    \"\"\"pass\"\"\"\n    status_key = self.get_status_key(instance)\n    cache.set(status_key, status, timeout=300)"}
{"i": 597, "got": "def get_mode(self, old_mode=None):\n    \"\"\"pass\"\"\"\n    if self.mode is not None:\n        return self.mode\n    assert self.can_write, 'This format does not have a supported output mode.'\n    if old_mode is None:\n        return self.output_modes[0]\n    if old_mode in self.output_modes:\n        return old_mode\n    try:\n        idx = PILLOW_MODES.index(old_mode)\n    except ValueError:\n        return self.output_modes[0]\n    for mode in PILLOW_MODES[idx + 1:]:\n        if mode in self.output_modes:\n            return mode\n    opposite = PILLOW_MODES[:idx]\n    opposite.reverse()\n    for mode in opposite:\n        if mode in self.output_modes:\n            return mode"}
{"i": 598, "got": "def token_at_cursor(code, pos=0):\n    \"\"\"pass\"\"\"\n    l = len(code)\n    end = start = pos\n    while end < l and code[end].isalpha():\n        end += 1\n    while start > 0 and code[start - 1].isalpha():\n        start -= 1\n    if start > 0 and code[start - 1] == '%':\n        start -= 1\n    return (code[start:end], start)"}
{"i": 599, "got": "def _send(self, data, msg_type='ok', silent=False):\n    \"\"\"pass\"\"\"\n    if data is not None:\n        try:\n            self._klog.debug('msg to frontend (%d): %.160s...', silent, data)\n        except Exception as e:\n            self._klog.warn(\"can't log response: %s\", e)\n        if not silent:\n            if msg_type != 'raw':\n                data = data_msg(data, mtype=msg_type)\n            self.send_response(self.iopub_socket, 'display_data', data)\n    return {'status': 'error' if msg_type == 'error' else 'ok', 'execution_count': self.execution_count, 'payload': [], 'user_expressions': {}}"}