Add files using upload-large-folder tool

benchmarks/csn-3.12-licensed/src/00036.py

@@ -0,0 +1,7 @@
+def add_transformers(line):
+    """pass"""
+    assert FROM_EXPERIMENTAL.match(line)
+    line = FROM_EXPERIMENTAL.sub(' ', line)
+    line = line.split('#')[0]
+    for trans in line.replace(' ', '').split(','):
+        import_transformer(trans)

benchmarks/csn-3.12-licensed/src/00058.py

@@ -0,0 +1,4 @@
+def release_assets(self, release):
+    """pass"""
+    release = self.as_id(release)
+    return self.get_list(url='%s/%s/assets' % (self, release))

benchmarks/csn-3.12-licensed/src/00082.py

@@ -0,0 +1,3 @@
+def check_arrange_act_spacing(self) -> typing.Generator[AAAError, None, None]:
+    """pass"""
+    yield from self.check_block_spacing(LineType.arrange, LineType.act, 'AAA03 expected 1 blank line before Act block, found {}')

benchmarks/csn-3.12-licensed/src/00090.py

@@ -0,0 +1,4 @@
+def remove_webhook(self):
+    """pass"""
+    if self._webhook.get('hook_id'):
+        self._request('{}/{}'.format(MINUT_WEBHOOKS_URL, self._webhook['hook_id']), request_type='DELETE')

benchmarks/csn-3.12-licensed/src/00093.py

@@ -0,0 +1,8 @@
+def put(filenames, file_type='auto', history_id=None):
+    """pass"""
+    history_id = history_id or os.environ['HISTORY_ID']
+    gi = get_galaxy_connection(history_id=history_id)
+    for filename in filenames:
+        log.debug('Uploading gx=%s history=%s localpath=%s ft=%s', gi, history_id, filename, file_type)
+        history = gi.histories.get(history_id)
+        history.upload_dataset(filename, file_type=file_type)

benchmarks/csn-3.12-licensed/src/00101.py

@@ -0,0 +1,15 @@
+def compare_schemas(one, two):
+    """pass"""
+    one = _normalize_string_type(one)
+    two = _normalize_string_type(two)
+    _assert_same_types(one, two)
+    if isinstance(one, list):
+        return _compare_lists(one, two)
+    elif isinstance(one, dict):
+        return _compare_dicts(one, two)
+    elif isinstance(one, SCALAR_TYPES):
+        return one == two
+    elif one is None:
+        return one is two
+    else:
+        raise RuntimeError('Not allowed type "{type}"'.format(type=type(one).__name__))

benchmarks/csn-3.12-licensed/src/00103.py

@@ -0,0 +1,11 @@
+def convert_ecma_regex_to_python(value):
+    """pass"""
+    if not is_ecma_regex(value):
+        return PythonRegex(value, [])
+    parts = value.split('/')
+    flags = parts.pop()
+    try:
+        result_flags = [ECMA_TO_PYTHON_FLAGS[f] for f in flags]
+    except KeyError:
+        raise ValueError('Wrong flags "{}".'.format(flags))
+    return PythonRegex('/'.join(parts[1:]), result_flags)

benchmarks/csn-3.12-licensed/src/00106.py

@@ -0,0 +1,6 @@
+def get_field(self, field_name):
+    """pass"""
+    for attr_name, field in self:
+        if field_name == attr_name:
+            return field
+    raise errors.FieldNotFound('Field not found', field_name)

benchmarks/csn-3.12-licensed/src/00110.py

@@ -0,0 +1,15 @@
+def __update(self, row):
+    """pass"""
+    expr = self.__table.update().values(row)
+    for key in self.__update_keys:
+        expr = expr.where(getattr(self.__table.c, key) == row[key])
+    if self.__autoincrement:
+        expr = expr.returning(getattr(self.__table.c, self.__autoincrement))
+    res = expr.execute()
+    if res.rowcount > 0:
+        if self.__autoincrement:
+            first = next(iter(res))
+            last_row_id = first[0]
+            return last_row_id
+        return 0
+    return None

benchmarks/csn-3.12-licensed/src/00139.py

@@ -0,0 +1,5 @@
+def angle(v1, v2):
+    """pass"""
+    v1_u = unit_vector(v1)
+    v2_u = unit_vector(v2)
+    return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

benchmarks/csn-3.12-licensed/src/00162.py

@@ -0,0 +1,13 @@
+def setup_model_event_subscribers(config, model_cls, schema):
+    """pass"""
+    events_map = get_events_map()
+    model_events = schema.get('_event_handlers', {})
+    event_kwargs = {'model': model_cls}
+    for event_tag, subscribers in model_events.items():
+        type_, action = event_tag.split('_')
+        event_objects = events_map[type_][action]
+        if not isinstance(event_objects, list):
+            event_objects = [event_objects]
+        for sub_name in subscribers:
+            sub_func = resolve_to_callable(sub_name)
+            config.subscribe_to_events(sub_func, event_objects, **event_kwargs)

benchmarks/csn-3.12-licensed/src/00175.py

@@ -0,0 +1,3 @@
+def _gen_input_mask(mask):
+    """pass"""
+    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))

benchmarks/csn-3.12-licensed/src/00196.py

@@ -0,0 +1,9 @@
+def _compute_radii(self):
+    """pass"""
+    radii = self._get_user_components('radii')
+    if radii is None:
+        centers = self.components_['centers']
+        n_centers = centers.shape[0]
+        max_dist = np.max(pairwise_distances(centers))
+        radii = np.ones(n_centers) * max_dist / sqrt(2.0 * n_centers)
+    self.components_['radii'] = radii

benchmarks/csn-3.12-licensed/src/00206.py

@@ -0,0 +1,23 @@
+def download(self, url, path, force_refetch=False, nocache=False):
+    """pass"""
+    if os.path.isfile(path):
+        getLogger().info('File exists, download task skipped -> {path}'.format(path=path))
+        return True
+    try:
+        getLogger().info('Downloading: {url} -> {path}'.format(url=url, path=path))
+        response = self.fetch(url, force_refetch=force_refetch, nocache=nocache)
+        if response is not None:
+            local_file = open(path, 'wb')
+            local_file.write(response)
+            local_file.close()
+            return True
+        else:
+            return False
+    except Exception as e:
+        if hasattr(e, 'reason'):
+            getLogger().exception('We failed to reach a server. Reason: %s' % (e.reason,))
+        elif hasattr(e, 'code'):
+            getLogger().exception("The server couldn't fulfill the request. Error code: {code}".format(code=e.code))
+        else:
+            getLogger().exception('Unknown error: %s' % (e,))
+    return False

benchmarks/csn-3.12-licensed/src/00219.py

@@ -0,0 +1,5 @@
+def voice(self):
+    """pass"""
+    dbid = self.lldb.dbid
+    text, lang = self._voiceoverdb.get_text_lang(dbid)
+    return (text, lang)

benchmarks/csn-3.12-licensed/src/00246.py

@@ -0,0 +1,16 @@
+def build(self, columns):
+    """pass"""
+    self.columns = columns
+    default = dict(elements.default('default_'), **_safe_get(self.init_style, 'default_', {}))
+    self.style = elements.adopt({c: default for c in columns}, self.init_style)
+    self.style['default_'] = default
+    self.style['header_'] = self._compose('header_', {'align', 'width'})
+    self.style['aggregate_'] = self._compose('aggregate_', {'align', 'width'})
+    self.style['separator_'] = _safe_get(self.init_style, 'separator_', elements.default('separator_'))
+    lgr.debug('Validating style %r', self.style)
+    self.style['width_'] = _safe_get(self.init_style, 'width_', elements.default('width_'))
+    elements.validate(self.style)
+    self._setup_fields()
+    ngaps = len(self.columns) - 1
+    self.width_separtor = len(self.style['separator_']) * ngaps
+    lgr.debug('Calculated separator width as %d', self.width_separtor)

benchmarks/csn-3.12-licensed/src/00305.py

@@ -0,0 +1,14 @@
+def _reload(self):
+    """pass"""
+    ConfigModel = apps.get_model('djconfig.Config')
+    cache = {}
+    data = dict(ConfigModel.objects.all().values_list('key', 'value'))
+    for form_class in self._registry:
+        empty_form = form_class()
+        cache.update({name: field.initial for name, field in empty_form.fields.items()})
+        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))})
+        form.is_valid()
+        cache.update({name: _unlazify(value) for name, value in form.cleaned_data.items() if name in data})
+        cache.update({name: data[name] for name, field in empty_form.fields.items() if name in data and isinstance(field, forms.FileField)})
+    cache['_updated_at'] = data.get('_updated_at')
+    self._cache = cache

benchmarks/csn-3.12-licensed/src/00317.py

@@ -0,0 +1,7 @@
+def receive(self, decode=True):
+    """pass"""
+    payload = self.socket.recv()
+    payload = self.verify(payload)
+    if decode:
+        payload = self.decode(payload)
+    return payload

benchmarks/csn-3.12-licensed/src/00333.py

@@ -0,0 +1,15 @@
+def get_client(self):
+    """pass"""
+    if self._ssh is None:
+        self._connect()
+        return self._ssh
+    else:
+        try:
+            chan = self._ssh.get_transport().open_session()
+        except (socket.error, paramiko.SSHException):
+            logger.warning('Lost connection, reconnecting...')
+            self._ssh.close()
+            self._connect()
+        else:
+            chan.close()
+        return self._ssh

benchmarks/csn-3.12-licensed/src/00359.py

@@ -0,0 +1,4 @@
+def get_params_from_sqlalchemy_url(db_url):
+    """pass"""
+    result = urlsplit(db_url)
+    return {'database': result.path[1:], 'host': result.hostname, 'port': result.port, 'username': result.username, 'password': result.password, 'driver': result.scheme}

benchmarks/csn-3.12-licensed/src/00379.py

@@ -0,0 +1,14 @@
+def stop(self, timeout=10.0):
+    """pass"""
+    if self._send_greenlet is not None and self._send_queue.qsize() > 0:
+        self.wait_send(timeout=timeout)
+    if self._send_greenlet is not None:
+        gevent.kill(self._send_greenlet)
+        self._send_greenlet = None
+    if self._error_greenlet is not None:
+        gevent.kill(self._error_greenlet)
+        self._error_greenlet = None
+    if self._feedback_greenlet is not None:
+        gevent.kill(self._feedback_greenlet)
+        self._feedback_greenlet = None
+    return self._send_queue.qsize() < 1

benchmarks/csn-3.12-licensed/src/00440.py

@@ -0,0 +1,9 @@
+def get_history(self, filters=(), pagesize=15, offset=0):
+    """pass"""
+    response = None
+    try:
+        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})
+    except requests.exceptions.RequestException as ex:
+        raise RequestError(ex)
+    _validate_response(response)
+    return json.loads(response.text)

benchmarks/csn-3.12-licensed/src/00443.py

@@ -0,0 +1,11 @@
+def get_output_cache_key(self, placeholder_name, instance):
+    """pass"""
+    cachekey = self.get_output_cache_base_key(placeholder_name, instance)
+    if self.cache_output_per_site:
+        cachekey = '{0}-s{1}'.format(cachekey, settings.SITE_ID)
+    if self.cache_output_per_language:
+        user_language = get_language()
+        if user_language not in self.cache_supported_language_codes:
+            user_language = 'unsupported'
+        cachekey = '{0}.{1}'.format(cachekey, user_language)
+    return cachekey

benchmarks/csn-3.12-licensed/src/00446.py

@@ -0,0 +1,7 @@
+def set_cached_output(self, placeholder_name, instance, output):
+    """pass"""
+    cachekey = self.get_output_cache_key(placeholder_name, instance)
+    if self.cache_timeout is not DEFAULT_TIMEOUT:
+        cache.set(cachekey, output, self.cache_timeout)
+    else:
+        cache.set(cachekey, output)

benchmarks/csn-3.12-licensed/src/00447.py

@@ -0,0 +1,7 @@
+def render(self, request, instance, **kwargs):
+    """pass"""
+    render_template = self.get_render_template(request, instance, **kwargs)
+    if not render_template:
+        return str(_(u"{No rendering defined for class '%s'}" % self.__class__.__name__))
+    context = self.get_context(request, instance, **kwargs)
+    return self.render_to_string(request, render_template, context)

benchmarks/csn-3.12-licensed/src/00454.py

@@ -0,0 +1,8 @@
+def init_app(self, app):
+    """pass"""
+    if not hasattr(app, 'extensions'):
+        app.extensions = {}
+    app.extensions['flask-jwt-simple'] = self
+    self._set_default_configuration_options(app)
+    self._set_error_handler_callbacks(app)
+    app.config['PROPAGATE_EXCEPTIONS'] = True

benchmarks/csn-3.12-licensed/src/00464.py

@@ -0,0 +1,4 @@
+def treenav_undefined_url(request, item_slug):
+    """pass"""
+    item = get_object_or_404(treenav.MenuItem, slug=item_slug)
+    raise Http404

benchmarks/csn-3.12-licensed/src/00467.py

@@ -0,0 +1,7 @@
+def clean_cache(self, request):
+    """pass"""
+    treenav.delete_cache()
+    self.message_user(request, _('Cache menuitem cache cleaned successfully.'))
+    info = (self.model._meta.app_label, self.model._meta.model_name)
+    changelist_url = reverse('admin:%s_%s_changelist' % info, current_app=self.admin_site.name)
+    return redirect(changelist_url)

benchmarks/csn-3.12-licensed/src/00479.py

@@ -0,0 +1,5 @@
+def _date_based_where(self, type, query, where):
+    """pass"""
+    value = str(where['value']).zfill(2)
+    value = self.parameter(value)
+    return "strftime('%s', %s) %s %s" % (type, self.wrap(where['column']), where['operator'], value)

benchmarks/csn-3.12-licensed/src/00492.py

@@ -0,0 +1,8 @@
+def _plan_on_valid_line(self, at_line, final_line_count):
+    """pass"""
+    if at_line == 1 or at_line == final_line_count:
+        return True
+    after_version = self._lines_seen['version'] and self._lines_seen['version'][0] == 1 and (at_line == 2)
+    if after_version:
+        return True
+    return False

benchmarks/csn-3.12-licensed/src/00511.py

@@ -0,0 +1,3 @@
+def in_file(self, fn: str) -> Iterator[Statement]:
+    """pass"""
+    yield from self.__file_to_statements.get(fn, [])

benchmarks/csn-3.12-licensed/src/00529.py

@@ -0,0 +1,16 @@
+def _write_int(fname, data, append=True):
+    """pass"""
+    data_ex = pexdoc.exh.addex(ValueError, 'There is no data to save to file')
+    fos_ex = pexdoc.exh.addex(OSError, 'File *[fname]* could not be created: *[reason]*')
+    data_ex(len(data) == 0 or (len(data) == 1 and len(data[0]) == 0))
+    try:
+        pmisc.make_dir(fname)
+        mode = 'w' if append is False else 'a'
+        if sys.hexversion < 50331648:
+            with open(fname, mode) as file_handle:
+                csv.writer(file_handle, delimiter=',').writerows(data)
+        else:
+            with open(fname, mode, newline='') as file_handle:
+                csv.writer(file_handle, delimiter=',').writerows(data)
+    except (IOError, OSError) as eobj:
+        fos_ex(True, _MF('fname', fname, 'reason', eobj.strerror))

benchmarks/csn-3.12-licensed/src/00530.py

@@ -0,0 +1,34 @@
+def revdocs2reverts(rev_docs, radius=defaults.RADIUS, use_sha1=False, resort=False, verbose=False):
+    """pass"""
+    page_rev_docs = groupby(rev_docs, lambda rd: rd.get('page'))
+    for page_doc, rev_docs in page_rev_docs:
+        if verbose:
+            sys.stderr.write(page_doc.get('title') + ': ')
+            sys.stderr.flush()
+        if resort:
+            if verbose:
+                sys.stderr.write('(sorting) ')
+                sys.stderr.flush()
+            rev_docs = sorted(rev_docs, key=lambda r: (r.get('timestamp'), r.get('id')))
+        detector = Detector(radius=radius)
+        for rev_doc in rev_docs:
+            if not use_sha1 and 'text' not in rev_doc:
+                logger.warn("Skipping {0}: 'text' field not found in {0}".format(rev_doc['id'], rev_doc))
+                continue
+            if use_sha1:
+                checksum = rev_doc.get('sha1') or DummyChecksum()
+            elif 'text' in rev_doc:
+                text_bytes = bytes(rev_doc['text'], 'utf8', 'replace')
+                checksum = hashlib.sha1(text_bytes).digest()
+            revert = detector.process(checksum, rev_doc)
+            if revert:
+                yield revert.to_json()
+                if verbose:
+                    sys.stderr.write('r')
+                    sys.stderr.flush()
+            elif verbose:
+                sys.stderr.write('.')
+                sys.stderr.flush()
+        if verbose:
+            sys.stderr.write('\n')
+            sys.stderr.flush()

benchmarks/csn-3.12-licensed/src/00538.py

@@ -0,0 +1,9 @@
+def at_line(self, line: FileLine) -> Iterator[InsertionPoint]:
+    """pass"""
+    logger.debug('finding insertion points at line: %s', str(line))
+    filename = line.filename
+    line_num = line.num
+    for ins in self.in_file(filename):
+        if line_num == ins.location.line:
+            logger.debug('found insertion point at line [%s]: %s', str(line), ins)
+            yield ins

benchmarks/csn-3.12-licensed/src/00555.py

@@ -0,0 +1,8 @@
+def get_commit_url(repo_url):
+    """pass"""
+    if 'github.com' in repo_url:
+        return repo_url[:-4] if repo_url.endswith('.git') else repo_url
+    if 'git.openstack.org' in repo_url:
+        uri = '/'.join(repo_url.split('/')[-2:])
+        return 'https://github.com/{0}'.format(uri)
+    return repo_url

benchmarks/csn-3.12-licensed/src/00557.py

@@ -0,0 +1,13 @@
+def checkout(repo, ref):
+    """pass"""
+    if ref in repo.branches:
+        log.warn('Removing local branch {b} for repo {r}'.format(b=ref, r=repo))
+        repo.head.reset(index=True, working_tree=True)
+        repo.git.checkout(repo.head.commit.hexsha)
+        repo.delete_head(ref, '--force')
+    log.info('Checkout out repo {repo} to ref {ref}'.format(repo=repo, ref=ref))
+    repo.head.reset(index=True, working_tree=True)
+    repo.git.checkout(ref)
+    repo.head.reset(index=True, working_tree=True)
+    sha = repo.head.commit.hexsha
+    log.info('Current SHA for repo {repo} is {sha}'.format(repo=repo, sha=sha))

benchmarks/csn-3.12-licensed/src/00567.py

@@ -0,0 +1,3 @@
+def save_list(key, *values):
+    """pass"""
+    return json.dumps({key: [_get_json(value) for value in values]})

benchmarks/csn-3.12-licensed/src/00580.py

@@ -0,0 +1,47 @@
+def generate_method_definition(func):
+    """pass"""
+    indent = 4
+    method_definition = ' ' * indent + 'def ' + func['name']
+    params_required = [param for param in func['arguments'] if param['is_required']]
+    params_optional = [param for param in func['arguments'] if not param['is_required']]
+    method_definition += '(self, '
+    for param in params_required:
+        method_definition += param['name']
+        method_definition += ', '
+    for param in params_optional:
+        method_definition += param['name']
+        method_definition += '=None, '
+    method_definition = method_definition.rstrip(', ') + '):\n'
+    indent += 4
+    method_definition += ' ' * indent
+    method_definition += '"""' + func['description']
+    method_definition += '\n\n' + ' ' * indent
+    for param in params_required + params_optional:
+        method_definition += ':param ' + DTYPE_MAPPING[param['type'].lower()]
+        method_definition += ' ' + param['name'] + ': '
+        method_definition += param['description']
+        method_definition += '\n' if param['is_required'] else ' (Optional)\n'
+        method_definition += ' ' * indent
+    open_index = func['returns'].find('(')
+    close_index = func['returns'].find(')', open_index if open_index > -1 else 0)
+    func['returns'] = func['returns'].replace('\t', ' ' * 4)
+    return_string = func['returns'].replace('\n', '')
+    if open_index < close_index and func['returns'][open_index + 1:close_index] in DTYPE_MAPPING:
+        method_definition += ':rtype: ' + DTYPE_MAPPING[func['returns'][open_index + 1:close_index]]
+        func['returns'] = func['returns'].replace(func['returns'][open_index:close_index + 1], '')
+        method_definition += '\n' + ' ' * indent
+    method_definition += ':return: ' + return_string
+    for i in range(0, len(return_string) + 1, 80 - (indent + 2)):
+        method_definition += return_string[i:i + (80 - (indent + 2))] + '\n' + ' ' * indent
+    method_definition += '"""' + '\n' + ' ' * indent
+    params_map = '__params_map = {'
+    params_indent, num_params = (len(params_map), len(params_required) + len(params_optional))
+    method_definition += params_map
+    for i, param in enumerate(params_required + params_optional):
+        method_definition += "'" + param['name'] + "': " + param['name']
+        if not param['is_required']:
+            method_definition + ' if ' + param['name'] + 'is not None else None'
+        method_definition += ',\n' + ' ' * indent + ' ' * params_indent if i + 1 < num_params else ''
+    method_definition += '}\n\n' + ' ' * indent
+    method_definition += "return self.make_request(SERVER_ADDRESS, '" + func['name'] + "', " + params_map.rstrip(' = {') + ', timeout=self.timeout)\n\n'
+    return method_definition

benchmarks/csn-3.12-licensed/src/00594.py

@@ -0,0 +1,4 @@
+def get_status_key(self, instance):
+    """pass"""
+    key_id = 'inst_%s' % id(instance) if instance.pk is None else instance.pk
+    return '%s.%s-%s-%s' % (instance._meta.app_label, get_model_name(instance), key_id, self.field.name)

benchmarks/csn-3.12-licensed/src/00595.py

@@ -0,0 +1,6 @@
+def get_status(self, instance):
+    """pass"""
+    status_key, status = self._get_status(instance)
+    if status['state'] in ['complete', 'error']:
+        cache.delete(status_key)
+    return status