ShijiaD/CodeXGLUE-Code-Docstring-Test
04
1[
2 {
3 "code": "def apply_option(self, cmd, option, active=True):\n return re.sub(r'{{{}\\:(?P<option>[^}}]*)}}'.format(option),\n '\\g<option>' if active else '', cmd)"
4 },
5 {
6 "code": "def make_local_static_report_files(self):\n for static, pkgdir in self.STATIC_FILES:\n shutil.copyfile(\n data_filename(static, pkgdir),\n os.path.join(self.directory, static)\n )\n if self.extra_css:\n shutil.copyfile(\n self.config.extra_css,\n os.path.join(self.directory, self.extra_css)\n )"
7 },
8 {
9 "code": "def format_filesize(size):\n for suffix in (\"bytes\", \"KB\", \"MB\", \"GB\", \"TB\"):\n if size < 1024.0:\n if suffix in (\"GB\", \"TB\"):\n return \"{0:3.2f} {1}\".format(size, suffix)\n else:\n return \"{0:3.1f} {1}\".format(size, suffix)\n size /= 1024.0"
10 },
11 {
12 "code": "def add_lexicon_ref(self, lrid, name, lrtype, url, lexicon_id,\n lexicon_name, datcat_id=None, datcat_name=None):\n self.lexicon_refs[lrid] = {\n 'LEX_REF_ID': lrid,\n 'NAME': name,\n 'TYPE': lrtype,\n 'URL': url,\n 'LEXICON_ID': lexicon_id,\n 'LEXICON_NAME': lexicon_name,\n 'DATCAT_ID': datcat_id,\n 'DATCAT_NAME': datcat_name\n }"
13 },
14 {
15 "code": "def invert_hash(self, tok_hash):\n return [tok_encoded.decode('utf8')\n for (_, tok_encoded) in\n self.client.scan_keys(HASH_KEYWORD_INDEX_TABLE,\n ((tok_hash,), (tok_hash,)))]"
16 },
17 {
18 "code": "def find_unique_points(explored_parameters):\n ranges = [param.f_get_range(copy=False) for param in explored_parameters]\n zipped_tuples = list(zip(*ranges))\n try:\n unique_elements = OrderedDict()\n for idx, val_tuple in enumerate(zipped_tuples):\n if val_tuple not in unique_elements:\n unique_elements[val_tuple] = []\n unique_elements[val_tuple].append(idx)\n return list(unique_elements.items())\n except TypeError:\n logger = logging.getLogger('pypet.find_unique')\n logger.error('Your parameter entries could not be hashed, '\n 'now I am sorting slowly in O(N**2).')\n unique_elements = []\n for idx, val_tuple in enumerate(zipped_tuples):\n matches = False\n for added_tuple, pos_list in unique_elements:\n matches = True\n for idx2, val in enumerate(added_tuple):\n if not explored_parameters[idx2]._equal_values(val_tuple[idx2], val):\n matches = False\n break\n if matches:\n pos_list.append(idx)\n break\n if not matches:\n unique_elements.append((val_tuple, [idx]))\n return unique_elements"
19 },
20 {
21 "code": "def unfinished(cls):\n return [\n cls.NONE,\n cls.SCHEDULED,\n cls.QUEUED,\n cls.RUNNING,\n cls.SHUTDOWN,\n cls.UP_FOR_RETRY,\n cls.UP_FOR_RESCHEDULE\n ]"
22 },
23 {
24 "code": "def merge_left(field, local_task, remote_issue, hamming=False):\n local_field = local_task.get(field, [])\n remote_field = remote_issue.get(field, [])\n if field not in local_task:\n local_task[field] = []\n new_count = 0\n for remote in remote_field:\n for local in local_field:\n if (\n (\n hamming\n and get_annotation_hamming_distance(remote, local) == 0\n )\n or (\n remote == local\n )\n ):\n break\n else:\n log.debug(\"%s not found in %r\" % (remote, local_field))\n local_task[field].append(remote)\n new_count += 1\n if new_count > 0:\n log.debug('Added %s new values to %s (total: %s)' % (\n new_count, field, len(local_task[field]),))"
25 },
26 {
27 "code": "def images(self, query=None):\n from sregistry.database.models import Collection, Container\n rows = []\n if query is not None: \n like = \"%\" + query + \"%\"\n containers = Container.query.filter(or_(Container.name == query,\n Container.tag.like(like),\n Container.uri.like(like),\n Container.name.like(like))).all() \n else:\n containers = Container.query.all()\n if len(containers) > 0:\n message = \" [date] [client]\\t[uri]\"\n bot.custom(prefix='Containers:', message=message, color=\"RED\")\n for c in containers:\n uri = c.get_uri()\n created_at = c.created_at.strftime('%B %d, %Y')\n rows.append([created_at, \" [%s]\" %c.client, uri])\n bot.table(rows) \n return containers"
28 },
29 {
30 "code": "def set_max_in_flight(self, max_in_flight):\n assert isinstance(max_in_flight, int)\n self.max_in_flight = max_in_flight\n if max_in_flight == 0:\n for conn in itervalues(self.conns):\n if conn.rdy > 0:\n logger.debug('[%s:%s] rdy: %d -> 0', conn.id, self.name, conn.rdy)\n self._send_rdy(conn, 0)\n self.total_rdy = 0\n else:\n self.need_rdy_redistributed = True\n self._redistribute_rdy_state()"
31 },
32 {
33 "code": "def _store(self, lines, buffer=None, store='source'):\n if buffer is None:\n buffer = self._buffer\n if lines.endswith('\\n'):\n buffer.append(lines)\n else:\n buffer.append(lines+'\\n')\n setattr(self, store, self._set_source(buffer))"
34 },
35 {
36 "code": "def _ast_option_group_to_code(self, option_group, **kwargs):\n lines = [\"option(\"]\n lines.extend(self._indent(self._ast_to_code(option_group.expression)))\n lines.append(\")\")\n return lines"
37 },
38 {
39 "code": "def add(symbol: str, date, value, currency: str):\n symbol = symbol.upper()\n currency = currency.upper()\n app = PriceDbApplication()\n price = PriceModel()\n price.symbol.parse(symbol)\n price.datum.from_iso_date_string(date)\n price.value = Decimal(value)\n price.currency = currency\n app.add_price(price)\n app.save()\n click.echo(\"Price added.\")"
40 },
41 {
42 "code": "def _close(self):\n if self.connection:\n with self.wrap_database_errors:\n self.connection.client.close()"
43 },
44 {
45 "code": "def _get_byte_parser(self):\n if not self._byte_parser:\n self._byte_parser = \\\n ByteParser(text=self.text, filename=self.filename)\n return self._byte_parser"
46 },
47 {
48 "code": "def _configureShortcuts(self):\n self._upShortcut = QtGui.QShortcut(\n QtGui.QKeySequence('Backspace'), self\n )\n self._upShortcut.setAutoRepeat(False)\n self._upShortcut.activated.connect(self._onNavigateUpButtonClicked)"
49 },
50 {
51 "code": "def update_message_dict(message_dict,action):\n global g_ok_java_messages\n allKeys = g_ok_java_messages.keys()\n for key in message_dict.keys():\n if key in allKeys:\n for message in message_dict[key]:\n if action == 1:\n if message not in g_ok_java_messages[key]:\n g_ok_java_messages[key].append(message)\n if action == 2:\n if message in g_ok_java_messages[key]:\n g_ok_java_messages[key].remove(message)\n else:\n if action == 1:\n g_ok_java_messages[key] = message_dict[key]"
52 },
53 {
54 "code": "def _addHdlProcToRun(self, trigger: SimSignal, proc) -> None:\n if not self._applyValPlaned:\n self._scheduleApplyValues()\n if isEvDependentOn(trigger, proc):\n if self.now == 0:\n return\n self._seqProcsToRun.append(proc)\n else:\n self._combProcsToRun.append(proc)"
55 },
56 {
57 "code": "def resolve_backend_name(name, backends, deprecated, aliased):\n available = [backend.name() for backend in backends]\n resolved_name = deprecated.get(name, aliased.get(name, name))\n if isinstance(resolved_name, list):\n resolved_name = next((b for b in resolved_name if b in available), \"\")\n if resolved_name not in available:\n raise LookupError(\"backend '{}' not found.\".format(name))\n if name in deprecated:\n logger.warning(\"WARNING: '%s' is deprecated. Use '%s'.\", name, resolved_name)\n return resolved_name"
58 },
59 {
60 "code": "def _rewrite_insert_nothing(self, sql, params, returning):\n conflict_target = self._build_conflict_target()\n where_clause = ' AND '.join([\n '{0} = %s'.format(self._format_field_name(field_name))\n for field_name in self.query.conflict_target\n ])\n where_clause_params = [\n self._format_field_value(field_name)\n for field_name in self.query.conflict_target\n ]\n params = params + tuple(where_clause_params)\n return (\n (\n 'WITH insdata AS ('\n '{insert} ON CONFLICT {conflict_target} DO UPDATE'\n ' SET {pk_column} = NULL WHERE FALSE RETURNING {returning})'\n ' SELECT * FROM insdata UNION ALL'\n ' SELECT {returning} FROM {table} WHERE {where_clause} LIMIT 1;'\n ).format(\n insert=sql,\n conflict_target=conflict_target,\n pk_column=self.qn(self.query.model._meta.pk.column),\n returning=returning,\n table=self.query.objs[0]._meta.db_table,\n where_clause=where_clause\n ),\n params\n )"
61 },
62 {
63 "code": "def get_stores(self, search_term):\n params = {'SearchText': search_term}\n response = self.__get('/storefindermap/storesearch', params=params)\n return Stores(response.json())"
64 },
65 {
66 "code": "def list_recommendations(\n self, keywords=None, max_domain_recommendations=None, custom_headers=None, raw=False, **operation_config):\n parameters = models.DomainRecommendationSearchParameters(keywords=keywords, max_domain_recommendations=max_domain_recommendations)\n def internal_paging(next_link=None, raw=False):\n if not next_link:\n url = self.list_recommendations.metadata['url']\n path_format_arguments = {\n 'subscriptionId': self._serialize.url(\"self.config.subscription_id\", self.config.subscription_id, 'str')\n }\n url = self._client.format_url(url, **path_format_arguments)\n query_parameters = {}\n query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n else:\n url = next_link\n query_parameters = {}\n header_parameters = {}\n header_parameters['Accept'] = 'application/json'\n header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n if self.config.generate_client_request_id:\n header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n if custom_headers:\n header_parameters.update(custom_headers)\n if self.config.accept_language is not None:\n header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n body_content = self._serialize.body(parameters, 'DomainRecommendationSearchParameters')\n request = self._client.post(url, query_parameters, header_parameters, body_content)\n response = self._client.send(request, stream=False, **operation_config)\n if response.status_code not in [200]:\n raise models.DefaultErrorResponseException(self._deserialize, response)\n return response\n deserialized = models.NameIdentifierPaged(internal_paging, self._deserialize.dependencies)\n if raw:\n header_dict = {}\n client_raw_response = models.NameIdentifierPaged(internal_paging, self._deserialize.dependencies, header_dict)\n return client_raw_response\n return deserialized"
67 },
68 {
69 "code": "def query_string(self, **params):\n return SearchResult(self, self._api.get(self._href, **params))"
70 },
71 {
72 "code": "def add_bias(self, name, size, mean=0, std=1):\n mean = self.kwargs.get('mean_{}'.format(name), mean)\n std = self.kwargs.get('std_{}'.format(name), std)\n self._params.append(theano.shared(\n util.random_vector(size, mean, std, rng=self.rng),\n name=self._fmt(name)))"
73 },
74 {
75 "code": "def ancestors(self, lhs, rhs):\n def _search(node):\n if node in lhs:\n return True\n if not node.parent:\n return False\n return _search(node.parent)\n return [node for node in rhs if _search(node)]"
76 },
77 {
78 "code": "def get_prices_on(self, on_date: str, namespace: str, symbol: str):\n repo = self.get_price_repository()\n query = (\n repo.query.filter(dal.Price.namespace == namespace)\n .filter(dal.Price.symbol == symbol)\n .filter(dal.Price.date == on_date)\n .order_by(dal.Price.time.desc())\n )\n result = query.first()\n return result"
79 },
80 {
81 "code": "def getEvents(self):\n events = []\n for json in self.conn.endpoints[\"self\"].getEvents():\n events.append(SkypeEvent.fromRaw(self, json))\n return events"
82 },
83 {
84 "code": "def prepare(self):\n self.output_dim = 10\n self.encoder = Chain(self.input_dim).stack(Dense(self.internal_layer_size, 'tanh'))\n self.decoder = Chain(self.internal_layer_size).stack(Dense(self.input_dim))\n self.classifier = Chain(self.internal_layer_size).stack(Dense(50, 'tanh'),\n Dense(self.output_dim),\n Softmax())\n self.register_inner_layers(self.encoder, self.decoder, self.classifier)\n self.target_input = T.ivector('target')\n self.register_external_inputs(self.target_input)"
85 },
86 {
87 "code": "def _set_configurations(self):\n logger.debug(\"======================\")\n logger.debug(\"Setting configurations\")\n logger.debug(\"======================\")\n resources = \"\"\n containers = \"\"\n params = \"\"\n manifest = \"\"\n if self.merge_params:\n params += self._get_merged_params_string()\n help_list = self._get_merged_params_help()\n else:\n params += self._get_params_string()\n help_list = self._get_params_help()\n for p in self.processes:\n if not p.directives:\n continue\n logger.debug(\"[{}] Adding directives: {}\".format(\n p.template, p.directives))\n resources += self._get_resources_string(p.directives, p.pid)\n containers += self._get_container_string(p.directives, p.pid)\n manifest = self._get_manifest_string()\n self.resources = self._render_config(\"resources.config\", {\n \"process_info\": resources\n })\n self.containers = self._render_config(\"containers.config\", {\n \"container_info\": containers\n })\n self.params = self._render_config(\"params.config\", {\n \"params_info\": params\n })\n self.manifest = self._render_config(\"manifest.config\", {\n \"manifest_info\": manifest\n })\n self.help = self._render_config(\"Helper.groovy\", {\n \"nf_file\": basename(self.nf_file),\n \"help_list\": help_list,\n \"version\": __version__,\n \"pipeline_name\": \" \".join([x.upper() for x in self.pipeline_name])\n })\n self.user_config = self._render_config(\"user.config\", {})"
88 },
89 {
90 "code": "def add_range(self, sequence, begin, end):\n sequence.parser_tree = parsing.Range(self.value(begin).strip(\"'\"),\n self.value(end).strip(\"'\"))\n return True"
91 },
92 {
93 "code": "def streams(self):\n result = self.db.read(self.path, {\"q\": \"ls\"})\n if result is None or result.json() is None:\n return []\n streams = []\n for s in result.json():\n strm = self[s[\"name\"]]\n strm.metadata = s\n streams.append(strm)\n return streams"
94 },
95 {
96 "code": "def truncate_string(data, headers, max_field_width=None, **_):\n return (([utils.truncate_string(v, max_field_width) for v in row] for row in data),\n [utils.truncate_string(h, max_field_width) for h in headers])"
97 },
98 {
99 "code": "def login(self):\n if self._session is None:\n self._session = requests.session()\n self._session.headers.update({'User-agent': str(UserAgent().random)})\n return self._post_login_page()"
100 },
101 {
102 "code": "def file_read(filename):\n fobj = open(filename,'r');\n source = fobj.read();\n fobj.close()\n return source"
103 },
104 {
105 "code": "def einsum_vecmul_index(gate_indices, number_of_qubits):\n mat_l, mat_r, tens_lin, tens_lout = _einsum_matmul_index_helper(gate_indices,\n number_of_qubits)\n return \"{mat_l}{mat_r}, \".format(mat_l=mat_l, mat_r=mat_r) + \\\n \"{tens_lin}->{tens_lout}\".format(tens_lin=tens_lin,\n tens_lout=tens_lout)"
106 },
107 {
108 "code": "def validate_widget(widget):\n if not has_valid_id(widget):\n raise InvalidWidget(\"%s must contain a valid 'id' attribute\" % widget.__name__)\n if not has_valid_name(widget):\n raise InvalidWidget(\"%s must contain a valid 'name' attribute\" % widget.__name__)\n if not has_valid_template(widget):\n raise InvalidWidget(\"%s must contain a valid 'template' attribute\" % widget.__name__)\n if not hasattr(widget, 'zones') or not widget.zones:\n raise InvalidWidget(\"%s must be compatible with at least one zone\" % widget.__name__)"
109 },
110 {
111 "code": "def institute(context, institute_id, sanger_recipient, coverage_cutoff, frequency_cutoff, \n display_name, remove_sanger):\n adapter = context.obj['adapter']\n LOG.info(\"Running scout update institute\")\n try:\n adapter.update_institute(\n internal_id=institute_id, \n sanger_recipient=sanger_recipient, \n coverage_cutoff=coverage_cutoff, \n frequency_cutoff=frequency_cutoff, \n display_name=display_name,\n remove_sanger=remove_sanger,\n )\n except Exception as err:\n LOG.warning(err)\n context.abort()"
112 },
113 {
114 "code": "def get_agency_id(relation):\n op = relation.tags.get('operator')\n if op:\n return int(hashlib.sha256(op.encode('utf-8')).hexdigest(), 16) % 10**8\n return -1"
115 },
116 {
117 "code": "def writes(nb, format, **kwargs):\n format = unicode(format)\n if format == u'json' or format == u'ipynb':\n return writes_json(nb, **kwargs)\n elif format == u'py':\n return writes_py(nb, **kwargs)\n else:\n raise NBFormatError('Unsupported format: %s' % format)"
118 },
119 {
120 "code": "def f_add_config_group(self, *args, **kwargs):\n return self._nn_interface._add_generic(self, type_name=CONFIG_GROUP,\n group_type_name=CONFIG_GROUP,\n args=args, kwargs=kwargs)"
121 },
122 {
123 "code": "def _get_authorization(self, request, httpclient):\n return 'WRAP access_token=\"' + \\\n self._get_token(request.host, request.path, httpclient) + '\"'"
124 },
125 {
126 "code": "def evaluate(self, expression, i1=None, i2=None, out=None, selection=None, delay=False):\n expression = _ensure_strings_from_expressions(expression)\n result = self.server._call_dataset(\"evaluate\", self, expression=expression, i1=i1, i2=i2, selection=selection, delay=delay)\n return result"
127 },
128 {
129 "code": "def _get_value(self, key, func=None, split_val=None, as_boolean=False,\n\t\texception_default=None):\n\t\ttry:\n\t\t\tif as_boolean:\n\t\t\t\treturn self.config.getboolean(key[0], key[1])\n\t\t\tvalue = self.config.get(key[0], key[1])\n\t\t\tif split_val is not None:\n\t\t\t\tvalue = value.split(split_val)\n\t\t\tif func is not None:\n\t\t\t\treturn func(value)\n\t\t\treturn value\n\t\texcept (KeyError, configparser.NoSectionError, configparser.NoOptionError) as e:\n\t\t\tif exception_default is not None:\n\t\t\t\treturn exception_default\n\t\t\traise KeyError(e)"
130 },
131 {
132 "code": "def get_system_cpu_times():\n user, system, idle = 0, 0, 0\n for cpu_time in _psutil_mswindows.get_system_cpu_times():\n user += cpu_time[0]\n system += cpu_time[1]\n idle += cpu_time[2]\n return _cputimes_ntuple(user, system, idle)"
133 },
134 {
135 "code": "def _spark_fit(self, cls, Z, *args, **kwargs):\n mapper = lambda X_y: super(cls, self).fit(\n X_y[0], X_y[1], *args, **kwargs\n )\n models = Z.map(mapper)\n avg = models.reduce(operator.add) / models.count()\n self.__dict__.update(avg.__dict__)\n return self"
136 },
137 {
138 "code": "def main(sample_id, assembly_file, coverage_file, coverage_bp_file, bam_file,\n opts, gsize):\n min_assembly_coverage, max_contigs = opts\n logger.info(\"Starting assembly mapping processing\")\n logger.info(\"Parsing coverage table\")\n coverage_info, a_cov = parse_coverage_table(coverage_file)\n a_size, contig_size = get_assembly_size(assembly_file)\n logger.info(\"Assembly processed with a total size of '{}' and coverage\"\n \" of '{}'\".format(a_size, a_cov))\n logger.info(\"Parsing coverage per bp table\")\n coverage_bp_data = get_coverage_from_file(coverage_bp_file)\n min_coverage = evaluate_min_coverage(min_assembly_coverage, a_cov, a_size)\n filtered_assembly = \"{}_filt.fasta\".format(\n os.path.splitext(assembly_file)[0])\n filtered_bam = \"filtered.bam\"\n logger.info(\"Checking filtered assembly\")\n if check_filtered_assembly(coverage_info, coverage_bp_data, min_coverage,\n gsize, contig_size, int(max_contigs),\n sample_id):\n logger.info(\"Filtered assembly passed minimum size threshold\")\n logger.info(\"Writting filtered assembly\")\n filter_assembly(assembly_file, min_coverage, coverage_info,\n filtered_assembly)\n logger.info(\"Filtering BAM file according to saved contigs\")\n filter_bam(coverage_info, bam_file, min_coverage, filtered_bam)\n else:\n shutil.copy(assembly_file, filtered_assembly)\n shutil.copy(bam_file, filtered_bam)\n shutil.copy(bam_file + \".bai\", filtered_bam + \".bai\")\n with open(\".status\", \"w\") as status_fh:\n status_fh.write(\"pass\")"
139 },
140 {
141 "code": "def fetchmany(self, size=None):\n self._check_executed()\n r = self._fetch_row(size or self.arraysize)\n self.rownumber = self.rownumber + len(r)\n if not r:\n self._warning_check()\n return r"
142 },
143 {
144 "code": "def find_source(self, filename):\n source = None\n base, ext = os.path.splitext(filename)\n TRY_EXTS = {\n '.py': ['.py', '.pyw'],\n '.pyw': ['.pyw'],\n }\n try_exts = TRY_EXTS.get(ext)\n if not try_exts:\n return filename, None\n for try_ext in try_exts:\n try_filename = base + try_ext\n if os.path.exists(try_filename):\n return try_filename, None\n source = self.coverage.file_locator.get_zip_data(try_filename)\n if source:\n return try_filename, source\n raise NoSource(\"No source for code: '%s'\" % filename)"
145 },
146 {
147 "code": "def get_document(self, document_id, database_name=None, collection_name=None):\n if document_id is None:\n raise AirflowBadRequest(\"Cannot get a document without an id\")\n try:\n return self.get_conn().ReadItem(\n get_document_link(\n self.__get_database_name(database_name),\n self.__get_collection_name(collection_name),\n document_id))\n except HTTPFailure:\n return None"
148 },
149 {
150 "code": "def execute_actions(self, cwd):\n self._execute_globals(cwd)\n for action in self.actions:\n logger.info(\"executing {}\".format(action))\n p = subprocess.Popen(action, shell=True, cwd=cwd)\n p.wait()"
151 },
152 {
153 "code": "def __var_find_to_py_ast(\n var_name: str, ns_name: str, py_var_ctx: ast.AST\n) -> GeneratedPyAST:\n return GeneratedPyAST(\n node=ast.Attribute(\n value=ast.Call(\n func=_FIND_VAR_FN_NAME,\n args=[\n ast.Call(\n func=_NEW_SYM_FN_NAME,\n args=[ast.Str(var_name)],\n keywords=[ast.keyword(arg=\"ns\", value=ast.Str(ns_name))],\n )\n ],\n keywords=[],\n ),\n attr=\"value\",\n ctx=py_var_ctx,\n )\n )"
154 },
155 {
156 "code": "def create_storage_account(self, service_name, description, label,\n affinity_group=None, location=None,\n geo_replication_enabled=None,\n extended_properties=None,\n account_type='Standard_GRS'):\n _validate_not_none('service_name', service_name)\n _validate_not_none('description', description)\n _validate_not_none('label', label)\n if affinity_group is None and location is None:\n raise ValueError(\n 'location or affinity_group must be specified')\n if affinity_group is not None and location is not None:\n raise ValueError(\n 'Only one of location or affinity_group needs to be specified')\n if geo_replication_enabled == False:\n account_type = 'Standard_LRS'\n return self._perform_post(\n self._get_storage_service_path(),\n _XmlSerializer.create_storage_service_input_to_xml(\n service_name,\n description,\n label,\n affinity_group,\n location,\n account_type,\n extended_properties),\n as_async=True)"
157 },
158 {
159 "code": "def set_selection(self, selection, name=\"default\", executor=None):\n def create(current):\n return selection\n self._selection(create, name, executor=executor, execute_fully=True)"
160 },
161 {
162 "code": "def set_resolved_name(self, ref: dict, type_name2solve: TypeName,\n type_name_ref: TypeName):\n if self.resolution[type_name2solve.value] is None:\n self.resolution[type_name2solve.value] = ref[type_name_ref.value]"
163 },
164 {
165 "code": "def format_data(self, data, scale=True):\n if len(self.analytes) == 1:\n d = nominal_values(data[self.analytes[0]])\n ds = np.array(list(zip(d, np.zeros(len(d)))))\n else:\n d = [nominal_values(data[a]) for a in self.analytes]\n ds = np.vstack(d).T\n finite = np.isfinite(ds).sum(1) == ds.shape[1]\n sampled = np.arange(data[self.analytes[0]].size)[finite]\n ds = ds[finite]\n if scale:\n ds = self.scaler.transform(ds)\n return ds, sampled"
166 },
167 {
168 "code": "def _referer(self, extension):\n iana_record = self.lookup.whois(\n PyFunceble.CONFIGURATION[\"iana_whois_server\"], \"hello.%s\" % extension\n )\n if iana_record and \"refer\" in iana_record:\n regex_referer = r\"(?s)refer\\:\\s+([a-zA-Z0-9._-]+)\\n\"\n matched = Regex(\n iana_record, regex_referer, return_data=True, group=1\n ).match()\n if matched:\n return matched\n if extension in self.manual_server:\n return self.manual_server[extension]\n return None"
169 },
170 {
171 "code": "def shape_rb_data(raw_rb):\n rb_data = []\n rb_data.append(np.mean(raw_rb, 0))\n rb_data.append(np.std(raw_rb, 0))\n return rb_data"
172 },
173 {
174 "code": "def update_function(self, name, body, update_mask):\n response = self.get_conn().projects().locations().functions().patch(\n updateMask=\",\".join(update_mask),\n name=name,\n body=body\n ).execute(num_retries=self.num_retries)\n operation_name = response[\"name\"]\n self._wait_for_operation_to_complete(operation_name=operation_name)"
175 },
176 {
177 "code": "def boolean(ctx, obj):\n if hasattr(obj, 'compute'):\n obj = next(seq.compute(ctx), '')\n else:\n obj = seq\n yield next(to_boolean(obj), '')"
178 },
179 {
180 "code": "def expects_none(options):\n if any(options.get(key) is not None for key in [\"count\", \"maximum\", \"minimum\", \"between\"]):\n return matches_count(0, options)\n else:\n return False"
181 },
182 {
183 "code": "def __early_downsample(y, sr, hop_length, res_type, n_octaves,\n nyquist, filter_cutoff, scale):\n downsample_count = __early_downsample_count(nyquist, filter_cutoff,\n hop_length, n_octaves)\n if downsample_count > 0 and res_type == 'kaiser_fast':\n downsample_factor = 2**(downsample_count)\n hop_length //= downsample_factor\n if len(y) < downsample_factor:\n raise ParameterError('Input signal length={:d} is too short for '\n '{:d}-octave CQT'.format(len(y), n_octaves))\n new_sr = sr / float(downsample_factor)\n y = audio.resample(y, sr, new_sr,\n res_type=res_type,\n scale=True)\n if not scale:\n y *= np.sqrt(downsample_factor)\n sr = new_sr\n return y, sr, hop_length"
184 },
185 {
186 "code": "def log_parser(self):\n size_stamp = os.path.getsize(self.log_file)\n self.log_retry = 0\n if size_stamp and size_stamp == self.log_sizestamp:\n return\n else:\n logger.debug(\"Updating log size stamp to: {}\".format(size_stamp))\n self.log_sizestamp = size_stamp\n r = \".* (.*) \\[.*\\].*\\[(.*)\\].*process > (.*) \\((.*)\\).*\"\n with open(self.log_file) as fh:\n for line in fh:\n if \"Submitted process >\" in line or \\\n \"Re-submitted process >\" in line or \\\n \"Cached process >\" in line:\n m = re.match(r, line)\n if not m:\n continue\n time_start = m.group(1)\n workdir = m.group(2)\n process = m.group(3)\n tag = m.group(4)\n if time_start + tag not in self.stored_log_ids:\n self.stored_log_ids.append(time_start + tag)\n else:\n continue\n if process not in self.processes:\n continue\n p = self.processes[process]\n if tag in list(p[\"finished\"]) + list(p[\"retry\"]):\n continue\n if tag in list(p[\"failed\"]) and \\\n \"Re-submitted process >\" in line:\n p[\"retry\"].add(tag)\n self.send = True\n continue\n p[\"barrier\"] = \"R\"\n if tag not in p[\"submitted\"]:\n p[\"submitted\"].add(tag)\n if tag not in self.process_tags[process]:\n self.process_tags[process][tag] = {\n \"workdir\": self._expand_path(workdir),\n \"start\": time_start\n }\n self.send = True\n elif not self.process_tags[process][tag][\"start\"]:\n self.process_tags[process][tag][\"start\"] = time_start\n self.send = True\n self._update_pipeline_status()"
187 },
188 {
189 "code": "def _remove_exploration(self):\n for param in self._explored_parameters.values():\n if param._stored:\n try:\n self.f_delete_item(param)\n except Exception:\n self._logger.exception('Could not delete expanded parameter `%s` '\n 'from disk.' % param.v_full_name)"
190 },
191 {
192 "code": "def setup_platform(hass, config, add_entities, discovery_info=None):\n host = config.get(CONF_HOST)\n token = config.get(CONF_ACCESS_TOKEN)\n name = config.get(CONF_NAME)\n volume_step = config.get(CONF_VOLUME_STEP)\n device_type = config.get(CONF_DEVICE_CLASS)\n device = VizioDevice(host, token, name, volume_step, device_type)\n if device.validate_setup() is False:\n _LOGGER.error(\"Failed to set up Vizio platform, \"\n \"please check if host and API key are correct\")\n return\n elif (token is None or token == \"\") and device_type == \"tv\":\n _LOGGER.error(\"Failed to set up Vizio platform, \"\n \"if device_class is 'tv' then an auth_token needs \"\n \"to be provided, otherwise if device_class is \"\n \"'soundbar' then add the right device_class to config\")\n return\n if config.get(CONF_SUPPRESS_WARNING):\n from requests.packages import urllib3\n _LOGGER.warning(\"InsecureRequestWarning is disabled \"\n \"because of Vizio platform configuration\")\n urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\n add_entities([device], True)"
193 },
194 {
195 "code": "def handle_oauth2_response(self, args):\n client = self.make_client()\n remote_args = {\n 'code': args.get('code'),\n 'client_secret': self.consumer_secret,\n 'redirect_uri': session.get('%s_oauthredir' % self.name)\n }\n log.debug('Prepare oauth2 remote args %r', remote_args)\n remote_args.update(self.access_token_params)\n headers = copy(self._access_token_headers)\n if self.access_token_method == 'POST':\n headers.update({'Content-Type': 'application/x-www-form-urlencoded'})\n body = client.prepare_request_body(**remote_args)\n resp, content = self.http_request(\n self.expand_url(self.access_token_url),\n headers=headers,\n data=to_bytes(body, self.encoding),\n method=self.access_token_method,\n )\n elif self.access_token_method == 'GET':\n qs = client.prepare_request_body(**remote_args)\n url = self.expand_url(self.access_token_url)\n url += ('?' in url and '&' or '?') + qs\n resp, content = self.http_request(\n url,\n headers=headers,\n method=self.access_token_method,\n )\n else:\n raise OAuthException(\n 'Unsupported access_token_method: %s' %\n self.access_token_method\n )\n data = parse_response(resp, content, content_type=self.content_type)\n if resp.code not in (200, 201):\n raise OAuthException(\n 'Invalid response from %s' % self.name,\n type='invalid_response', data=data\n )\n return data"
196 },
197 {
198 "code": "def decode(self, val):\n new_val = self.decode_date(val)\n if val != new_val:\n return new_val\n return json.JSONDecoder.decode(self, val)"
199 },
200 {
201 "code": "def extractPrintSaveIntermittens():\n global g_summary_dict_intermittents\n localtz = time.tzname[0]\n for ind in range(len(g_summary_dict_all[\"TestName\"])):\n if g_summary_dict_all[\"TestInfo\"][ind][\"FailureCount\"] >= g_threshold_failure:\n addFailedTests(g_summary_dict_intermittents, g_summary_dict_all, ind)\n if len(g_summary_dict_intermittents[\"TestName\"]) > 0:\n json.dump(g_summary_dict_intermittents, open(g_summary_dict_name, 'w'))\n with open(g_summary_csv_filename, 'w') as summaryFile:\n for ind in range(len(g_summary_dict_intermittents[\"TestName\"])):\n testName = g_summary_dict_intermittents[\"TestName\"][ind]\n numberFailure = g_summary_dict_intermittents[\"TestInfo\"][ind][\"FailureCount\"]\n firstFailedTS = parser.parse(time.ctime(min(g_summary_dict_intermittents[\"TestInfo\"][ind][\"Timestamp\"]))+\n ' '+localtz)\n firstFailedStr = firstFailedTS.strftime(\"%a %b %d %H:%M:%S %Y %Z\")\n recentFail = parser.parse(time.ctime(max(g_summary_dict_intermittents[\"TestInfo\"][ind][\"Timestamp\"]))+\n ' '+localtz)\n recentFailStr = recentFail.strftime(\"%a %b %d %H:%M:%S %Y %Z\")\n eachTest = \"{0}, {1}, {2}, {3}\\n\".format(testName, recentFailStr, numberFailure,\n g_summary_dict_intermittents[\"TestInfo\"][ind][\"TestCategory\"][0])\n summaryFile.write(eachTest)\n print(\"Intermittent: {0}, Last failed: {1}, Failed {2} times since \"\n \"{3}\".format(testName, recentFailStr, numberFailure, firstFailedStr))"
202 },
203 {
204 "code": "def _get_rule_source(self, rule):\n p = len(self.input_source) + rule.position\n source = self.input_source[p:p + rule.consumed].rstrip()\n return self._indent(source, depth=self.indent + \" \", skip_first_line=True)"
205 },
206 {
207 "code": "def _resubscribe(self, soft=False):\n if self.bitfinex_config:\n self.send(**self.bitfinex_config)\n q_list = []\n while True:\n try:\n identifier, q = self.channel_configs.popitem(last=True if soft else False)\n except KeyError:\n break\n q_list.append((identifier, q.copy()))\n if identifier == 'auth':\n self.send(**q, auth=True)\n continue\n if soft:\n q['event'] = 'unsubscribe'\n self.send(**q)\n if soft:\n for identifier, q in reversed(q_list):\n self.channel_configs[identifier] = q\n self.send(**q)\n else:\n for identifier, q in q_list:\n self.channel_configs[identifier] = q"
208 },
209 {
210 "code": "def _receive_data(self):\n while True:\n while len(self._buffer) < self.max_size and self.conn.poll():\n data = self._read_chunks()\n if data is not None:\n self._buffer.append(data)\n if len(self._buffer) > 0:\n return self._buffer.popleft()"
211 },
212 {
213 "code": "def _build_purchase_item(course_id, course_url, cost_in_cents, mode, course_data, sku):\n item = {\n 'id': \"{}-{}\".format(course_id, mode),\n 'url': course_url,\n 'price': cost_in_cents,\n 'qty': 1,\n }\n if 'title' in course_data:\n item['title'] = course_data['title']\n else:\n item['title'] = 'Course {} mode: {}'.format(course_id, mode)\n if 'tags' in course_data:\n item['tags'] = course_data['tags']\n item['vars'] = dict(course_data.get('vars', {}), mode=mode, course_run_id=course_id)\n item['vars']['purchase_sku'] = sku\n return item"
214 },
215 {
216 "code": "def _vector_matrix(vs, ms):\n return tf.reduce_sum(input_tensor=vs[..., tf.newaxis] * ms, axis=-2)"
217 },
218 {
219 "code": "def mix_over_posterior_draws(means, variances):\n with tf.compat.v1.name_scope(\n 'mix_over_posterior_draws', values=[means, variances]):\n num_posterior_draws = dist_util.prefer_static_value(\n tf.shape(input=means))[0]\n component_observations = tfd.Independent(\n distribution=tfd.Normal(\n loc=dist_util.move_dimension(means, 0, -2),\n scale=tf.sqrt(dist_util.move_dimension(variances, 0, -2))),\n reinterpreted_batch_ndims=1)\n return tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n logits=tf.zeros([num_posterior_draws],\n dtype=component_observations.dtype)),\n components_distribution=component_observations)"
220 },
221 {
222 "code": "def DeleteItem(self, item):\r\n \"Remove the item from the list and unset the related data\"\r\n wx_data = self.GetItemData(item)\r\n py_data = self._py_data_map[wx_data]\r\n del self._py_data_map[wx_data]\r\n del self._wx_data_map[py_data]\r\n wx.ListCtrl.DeleteItem(self, item)"
223 },
224 {
225 "code": "def add_route(self, command, adapter):\n if not isinstance(adapter, BaseAdapter):\n try:\n adapter = self.adapter_aliases[adapter]\n except KeyError:\n self.adapter_aliases[adapter] = adapter = resolve_adapter(\n adapter\n )\n self.routes[command] = adapter\n return self"
226 },
227 {
228 "code": "def progress(iterator, prefix):\n if terminal_width(prefix) > 25:\n prefix = (\"..\" + get_cut_prefix(prefix, 23))\n speed_updated = start = time()\n speed_written = written = 0\n speed_history = deque(maxlen=5)\n for data in iterator:\n yield data\n now = time()\n elapsed = now - start\n written += len(data)\n speed_elapsed = now - speed_updated\n if speed_elapsed >= 0.5:\n speed_history.appendleft((\n written - speed_written,\n speed_updated,\n ))\n speed_updated = now\n speed_written = written\n speed_history_written = sum(h[0] for h in speed_history)\n speed_history_elapsed = now - speed_history[-1][1]\n speed = speed_history_written / speed_history_elapsed\n status = create_status_line(\n prefix=prefix,\n written=format_filesize(written),\n elapsed=format_time(elapsed),\n speed=format_filesize(speed)\n )\n print_inplace(status)\n sys.stderr.write(\"\\n\")\n sys.stderr.flush()"
229 },
230 {
231 "code": "def get_params(brightness, contrast, saturation, hue):\n transforms = []\n if brightness is not None:\n brightness_factor = random.uniform(brightness[0], brightness[1])\n transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor)))\n if contrast is not None:\n contrast_factor = random.uniform(contrast[0], contrast[1])\n transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))\n if saturation is not None:\n saturation_factor = random.uniform(saturation[0], saturation[1])\n transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor)))\n if hue is not None:\n hue_factor = random.uniform(hue[0], hue[1])\n transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor)))\n random.shuffle(transforms)\n transform = Compose(transforms)\n return transform"
232 },
233 {
234 "code": "def panel(context, panel, version, update_date, update_version):\n adapter = context.obj['adapter']\n panel_obj = adapter.gene_panel(panel, version=version)\n if not panel_obj:\n LOG.warning(\"Panel %s (version %s) could not be found\" % (panel, version))\n context.abort()\n date_obj = None\n if update_date:\n try:\n date_obj = get_date(update_date)\n except Exception as err:\n LOG.warning(err)\n context.abort()\n update_panel(\n adapter,\n panel,\n panel_version=panel_obj['version'],\n new_version=update_version,\n new_date=date_obj\n )"
235 },
236 {
237 "code": "def random_ports(port, n):\n for i in range(min(5, n)):\n yield port + i\n for i in range(n-5):\n yield port + random.randint(-2*n, 2*n)"
238 },
239 {
240 "code": "def PermissiveDict(fields=None):\n if fields:\n check_user_facing_fields_dict(fields, 'PermissiveDict')\n class _PermissiveDict(_ConfigComposite):\n def __init__(self):\n key = 'PermissiveDict.' + str(DictCounter.get_next_count())\n super(_PermissiveDict, self).__init__(\n name=None,\n key=key,\n fields=fields or dict(),\n description='A configuration dictionary with typed fields',\n type_attributes=ConfigTypeAttributes(is_builtin=True),\n )\n @property\n def is_permissive_composite(self):\n return True\n return _PermissiveDict"
241 },
242 {
243 "code": "def gravatar_url(user_or_email, size=GRAVATAR_DEFAULT_SIZE):\n if hasattr(user_or_email, 'email'):\n email = user_or_email.email\n else:\n email = user_or_email\n try:\n return escape(get_gravatar_url(email=email, size=size))\n except:\n return ''"
244 },
245 {
246 "code": "def run_as_cmd(cmd, user, shell='bash'):\n to_execute = get_shell(shell) + [EXECUTE_SHELL_PARAM, cmd]\n if user == 'root':\n return to_execute\n return ['sudo', '-s', '--set-home', '-u', user] + to_execute"
247 },
248 {
249 "code": "def profile_function(self):\n with _CodeHeatmapCalculator() as prof:\n result = self._run_object(*self._run_args, **self._run_kwargs)\n code_lines, start_line = inspect.getsourcelines(self._run_object)\n source_lines = []\n for line in code_lines:\n source_lines.append(('line', start_line, line))\n start_line += 1\n filename = os.path.abspath(inspect.getsourcefile(self._run_object))\n heatmap = prof.heatmap[filename]\n run_time = sum(time for time in heatmap.values())\n return {\n 'objectName': self._object_name,\n 'runTime': run_time,\n 'result': result,\n 'timestamp': int(time.time()),\n 'heatmaps': [{\n 'name': self._object_name,\n 'heatmap': heatmap,\n 'executionCount': prof.execution_count[filename],\n 'srcCode': source_lines,\n 'runTime': run_time\n }]\n }"
250 },
251 {
252 "code": "def dashboard(request):\n if not isinstance(mc_client, dict):\n cache_stats = _get_cache_stats()\n else:\n cache_stats = None\n if cache_stats:\n data = _context_data({\n 'title': _('Memcache Dashboard'),\n 'cache_stats': cache_stats,\n 'can_get_slabs': hasattr(mc_client, 'get_slabs'),\n 'REFRESH_RATE': SETTINGS['REFRESH_RATE'],\n },\n request)\n template = 'memcache_admin/dashboard.html'\n else:\n data = _context_data({\n 'title': _('Memcache Dashboard - Error'),\n 'error_message': _('Unable to connect to a memcache server.'),\n },\n request)\n template = 'memcache_admin/dashboard_error.html'\n return render_to_response(template, data, RequestContext(request))"
253 },
254 {
255 "code": "def _validate_initial_statevector(self):\n if self._initial_statevector is None:\n return\n length = len(self._initial_statevector)\n required_dim = 2 ** self._number_of_qubits\n if length != required_dim:\n raise BasicAerError('initial statevector is incorrect length: ' +\n '{} != {}'.format(length, required_dim))"
256 },
257 {
258 "code": "def chatToId(url):\n match = re.search(r\"conversations/([0-9]+:[^/]+)\", url)\n return match.group(1) if match else None"
259 },
260 {
261 "code": "def prepare_pids(self):\n self.pids = []\n for fetcher in self.pid_fetchers:\n val = fetcher(None, self.revisions[-1][1])\n if val:\n self.pids.append(val)"
262 },
263 {
264 "code": "def use(network=False):\n global _engine\n __engine = _engine\n activated = __engine.active\n if activated:\n __engine.disable()\n _engine = Engine(network=network)\n _engine.activate()\n yield _engine\n _engine.disable()\n if network:\n _engine.disable_network()\n _engine = __engine\n if activated:\n _engine.activate()"
265 },
266 {
267 "code": "def parse_yaml_linenumbers(data, filename):\n def compose_node(parent, index):\n line = loader.line\n node = Composer.compose_node(loader, parent, index)\n node.__line__ = line + 1\n return node\n def construct_mapping(node, deep=False):\n if ANSIBLE_VERSION < 2:\n mapping = Constructor.construct_mapping(loader, node, deep=deep)\n else:\n mapping = AnsibleConstructor.construct_mapping(loader, node, deep=deep)\n if hasattr(node, '__line__'):\n mapping[LINE_NUMBER_KEY] = node.__line__\n else:\n mapping[LINE_NUMBER_KEY] = mapping._line_number\n mapping[FILENAME_KEY] = filename\n return mapping\n try:\n if ANSIBLE_VERSION < 2:\n loader = yaml.Loader(data)\n else:\n import inspect\n kwargs = {}\n if 'vault_password' in inspect.getargspec(AnsibleLoader.__init__).args:\n kwargs['vault_password'] = DEFAULT_VAULT_PASSWORD\n loader = AnsibleLoader(data, **kwargs)\n loader.compose_node = compose_node\n loader.construct_mapping = construct_mapping\n data = loader.get_single_data()\n except (yaml.parser.ParserError, yaml.scanner.ScannerError) as e:\n raise SystemExit(\"Failed to parse YAML in %s: %s\" % (filename, str(e)))\n return data"
268 },
269 {
270 "code": "def log_cdf_laplace(x, name=\"log_cdf_laplace\"):\n with tf.name_scope(name):\n x = tf.convert_to_tensor(value=x, name=\"x\")\n lower_solution = -np.log(2.) + x\n safe_exp_neg_x = tf.exp(-tf.abs(x))\n upper_solution = tf.math.log1p(-0.5 * safe_exp_neg_x)\n return tf.where(x < 0., lower_solution, upper_solution)"
271 },
272 {
273 "code": "def samefile(path1, path2):\n info1 = fs.getfileinfo(path1)\n info2 = fs.getfileinfo(path2)\n return (info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber and\n info1.nFileIndexHigh == info2.nFileIndexHigh and\n info1.nFileIndexLow == info2.nFileIndexLow)"
274 },
275 {
276 "code": "def add_netnode_plugin_name(plugin_name):\n current_names = set(get_netnode_plugin_names())\n if plugin_name in current_names:\n return\n current_names.add(plugin_name)\n get_meta_netnode()[PLUGIN_NAMES_KEY] = json.dumps(list(current_names))"
277 },
278 {
279 "code": "def set_serial(self, hex_str):\n bignum_serial = _ffi.gc(_lib.BN_new(), _lib.BN_free)\n bignum_ptr = _ffi.new(\"BIGNUM**\")\n bignum_ptr[0] = bignum_serial\n bn_result = _lib.BN_hex2bn(bignum_ptr, hex_str)\n if not bn_result:\n raise ValueError(\"bad hex string\")\n asn1_serial = _ffi.gc(\n _lib.BN_to_ASN1_INTEGER(bignum_serial, _ffi.NULL),\n _lib.ASN1_INTEGER_free)\n _lib.X509_REVOKED_set_serialNumber(self._revoked, asn1_serial)"
280 },
281 {
282 "code": "def run_samblaster(job, sam):\n work_dir = job.fileStore.getLocalTempDir()\n job.fileStore.readGlobalFile(sam, os.path.join(work_dir, 'input.sam'))\n command = ['/usr/local/bin/samblaster',\n '-i', '/data/input.sam',\n '-o', '/data/output.sam',\n '--ignoreUnmated']\n start_time = time.time()\n dockerCall(job=job, workDir=work_dir,\n parameters=command,\n tool='quay.io/biocontainers/samblaster:0.1.24--0')\n end_time = time.time()\n _log_runtime(job, start_time, end_time, \"SAMBLASTER\")\n return job.fileStore.writeGlobalFile(os.path.join(work_dir, 'output.sam'))"
283 },
284 {
285 "code": "def handle_stranded_tasks(self, engine):\n lost = self.pending[engine]\n for msg_id in lost.keys():\n if msg_id not in self.pending[engine]:\n continue\n raw_msg = lost[msg_id].raw_msg\n idents,msg = self.session.feed_identities(raw_msg, copy=False)\n parent = self.session.unpack(msg[1].bytes)\n idents = [engine, idents[0]]\n try:\n raise error.EngineError(\"Engine %r died while running task %r\"%(engine, msg_id))\n except:\n content = error.wrap_exception()\n header = dict(\n status='error',\n engine=engine,\n date=datetime.now(),\n )\n msg = self.session.msg('apply_reply', content, parent=parent, subheader=header)\n raw_reply = map(zmq.Message, self.session.serialize(msg, ident=idents))\n self.dispatch_result(raw_reply)\n self.completed.pop(engine)\n self.failed.pop(engine)"
286 },
287 {
288 "code": "def get_group_all(group, path=None):\n result = []\n for config, distro in iter_files_distros(path=path):\n if group in config:\n for name, epstr in config[group].items():\n with BadEntryPoint.err_to_warnings():\n result.append(EntryPoint.from_string(epstr, name, distro))\n return result"
289 },
290 {
291 "code": "def build_filters_and_sizers(self, ppoi_value, create_on_demand):\n name = self.name\n if not name and self.field.placeholder_image_name:\n name = self.field.placeholder_image_name\n self.filters = FilterLibrary(\n name,\n self.storage,\n versatileimagefield_registry,\n ppoi_value,\n create_on_demand\n )\n for (\n attr_name,\n sizedimage_cls\n ) in iteritems(versatileimagefield_registry._sizedimage_registry):\n setattr(\n self,\n attr_name,\n sizedimage_cls(\n path_to_image=name,\n storage=self.storage,\n create_on_demand=create_on_demand,\n ppoi=ppoi_value\n )\n )"
292 },
293 {
294 "code": "def predict_logit(self, x, **kwargs):\n return self.feed_forward(x, **kwargs)[self.layers[-1].full_name('pre')]"
295 },
296 {
297 "code": "def get_source_lane(fork_process, pipeline_list):\n fork_source = fork_process[-1]\n fork_sig = [x for x in fork_process if x != \"__init__\"]\n for position, p in enumerate(pipeline_list[::-1]):\n if p[\"output\"][\"process\"] == fork_source:\n lane = p[\"output\"][\"lane\"]\n logger.debug(\"Possible source match found in position {} in lane\"\n \" {}\".format(position, lane))\n lane_sequence = [x[\"output\"][\"process\"] for x in pipeline_list\n if x[\"output\"][\"lane\"] == lane]\n logger.debug(\"Testing lane sequence '{}' against fork signature\"\n \" '{}'\".format(lane_sequence, fork_sig))\n if lane_sequence == fork_sig:\n return p[\"output\"][\"lane\"]\n return 0"
298 },
299 {
300 "code": "def article(self, msgid_article=None, decode=None):\n args = None\n if msgid_article is not None:\n args = utils.unparse_msgid_article(msgid_article)\n code, message = self.command(\"ARTICLE\", args)\n if code != 220:\n raise NNTPReplyError(code, message)\n parts = message.split(None, 1)\n try:\n articleno = int(parts[0])\n except ValueError:\n raise NNTPProtocolError(message)\n headers = utils.parse_headers(self.info_gen(code, message))\n decode = \"yEnc\" in headers.get(\"subject\", \"\")\n escape = 0\n crc32 = 0\n body = []\n for line in self.info_gen(code, message):\n if decode:\n if line.startswith(\"=y\"):\n continue\n line, escape, crc32 = yenc.decode(line, escape, crc32)\n body.append(line)\n return articleno, headers, \"\".join(body)"
301 },
302 {
303 "code": "def wrap_function(func=None, error_threshold=None, reraise_exception=True, save_current_stack_trace=True):\n if func:\n return flawless.client.client._wrap_function_with_error_decorator(\n func=func,\n error_threshold=error_threshold,\n reraise_exception=reraise_exception,\n save_current_stack_trace=save_current_stack_trace)\n else:\n return functools.partial(flawless.client.client._wrap_function_with_error_decorator,\n error_threshold=error_threshold,\n reraise_exception=reraise_exception,\n save_current_stack_trace=save_current_stack_trace)"
304 },
305 {
306 "code": "def post(self, url, params=None, data=None, files=None, **kwargs):\n return self.call_api(\n \"POST\",\n url,\n params=params,\n data=data,\n files=files,\n **kwargs\n )"
307 },
308 {
309 "code": "def is_dark_rgb(r, g, b):\n try:\n midpoint = int(environ.get('TERMINAL_COLOR_MIDPOINT', None))\n except:\n pass\n if not midpoint:\n term = environ.get('TERM', None)\n print(\"midpoint\", midpoint, 'vs', (16*5 + 16*g + 16*b))\n midpoint = 383 if term and term == 'xterm-256color' else 117963\n if ( (16*5 + 16*g + 16*b) < midpoint ):\n return True\n else:\n return False"
310 },
311 {
312 "code": "def stop(self):\n with self.synclock:\n if self.syncthread is not None:\n self.syncthread.cancel()\n self.syncthread = None"
313 },
314 {
315 "code": "def evaluate_marker(cls, text, extra=None):\n return cls.interpret(parser.expr(text).totuple(1)[1])"
316 },
317 {
318 "code": "def _get_job(self, project_id, job_id):\n job_name = 'projects/{}/jobs/{}'.format(project_id, job_id)\n request = self._mlengine.projects().jobs().get(name=job_name)\n while True:\n try:\n return request.execute()\n except HttpError as e:\n if e.resp.status == 429:\n time.sleep(30)\n else:\n self.log.error('Failed to get MLEngine job: {}'.format(e))\n raise"
319 },
320 {
321 "code": "def pause(self):\n for tracer in self.tracers:\n tracer.stop()\n stats = tracer.get_stats()\n if stats:\n print(\"\\nCoverage.py tracer stats:\")\n for k in sorted(stats.keys()):\n print(\"%16s: %s\" % (k, stats[k]))\n threading.settrace(None)"
322 },
323 {
324 "code": "def to_py(o, keyword_fn: Callable[[kw.Keyword], Any] = _kw_name):\n if isinstance(o, ISeq):\n return _to_py_list(o, keyword_fn=keyword_fn)\n elif not isinstance(\n o, (IPersistentList, IPersistentMap, IPersistentSet, IPersistentVector)\n ):\n return o\n else:\n return _to_py_backup(o, keyword_fn=keyword_fn)"
325 },
326 {
327 "code": "def indent(instr,nspaces=4, ntabs=0, flatten=False):\n if instr is None:\n return\n ind = '\\t'*ntabs+' '*nspaces\n if flatten:\n pat = re.compile(r'^\\s*', re.MULTILINE)\n else:\n pat = re.compile(r'^', re.MULTILINE)\n outstr = re.sub(pat, ind, instr)\n if outstr.endswith(os.linesep+ind):\n return outstr[:-len(ind)]\n else:\n return outstr"
328 },
329 {
330 "code": "def handleCONNACK(self, response):\n state = self.__class__.__name__\n log.error(\"Unexpected {packet:7} packet received in {log_source}\", packet=\"CONNACK\")"
331 },
332 {
333 "code": "def filter_bam(coverage_info, bam_file, min_coverage, output_bam):\n contig_list = [x for x, vals in coverage_info.items()\n if vals[\"cov\"] >= min_coverage]\n cli = [\n \"samtools\",\n \"view\",\n \"-bh\",\n \"-F\",\n \"4\",\n \"-o\",\n output_bam,\n \"-@\",\n \"1\",\n bam_file,\n ]\n cli += contig_list\n logger.debug(\"Runnig samtools view subprocess with command: {}\".format(\n cli))\n p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE)\n stdout, stderr = p.communicate()\n try:\n stderr = stderr.decode(\"utf8\")\n stdout = stdout.decode(\"utf8\")\n except (UnicodeDecodeError, AttributeError):\n stderr = str(stderr)\n stdout = str(stdout)\n logger.info(\"Finished samtools view subprocess with STDOUT:\\\\n\"\n \"======================================\\\\n{}\".format(stdout))\n logger.info(\"Fished samtools view subprocesswith STDERR:\\\\n\"\n \"======================================\\\\n{}\".format(stderr))\n logger.info(\"Finished samtools view with return code: {}\".format(\n p.returncode))\n if not p.returncode:\n cli = [\n \"samtools\",\n \"index\",\n output_bam\n ]\n logger.debug(\"Runnig samtools index subprocess with command: \"\n \"{}\".format(cli))\n p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE)\n stdout, stderr = p.communicate()\n try:\n stderr = stderr.decode(\"utf8\")\n stdout = stdout.decode(\"utf8\")\n except (UnicodeDecodeError, AttributeError):\n stderr = str(stderr)\n stdout = str(stdout)\n logger.info(\"Finished samtools index subprocess with STDOUT:\\\\n\"\n \"======================================\\\\n{}\".format(\n stdout))\n logger.info(\"Fished samtools index subprocesswith STDERR:\\\\n\"\n \"======================================\\\\n{}\".format(\n stderr))\n logger.info(\"Finished samtools index with return code: {}\".format(\n p.returncode))"
334 },
335 {
336 "code": "def create_tfs_tfvc_client(url, token=None):\n if token is None:\n token = os.environ.get('TFS_API_TOKEN', None)\n tfs_connection = create_tfs_connection(url, token)\n tfs_tfvc_client = tfs_connection.get_client('vsts.tfvc.v4_1.tfvc_client.TfvcClient')\n if tfs_tfvc_client is None:\n msg = 'Unable to create TFS Git Client, failed to connect to TFS Enterprise (%s) with provided token.'\n raise RuntimeError(msg, url)\n return tfs_tfvc_client"
337 },
338 {
339 "code": "def visualize_qualitative_analysis(inputs, model, samples=1, batch_size=3,\n length=8):\n average = lambda dist: tf.reduce_mean(\n input_tensor=dist.mean(), axis=0)\n with tf.compat.v1.name_scope(\"val_reconstruction\"):\n reconstruct = functools.partial(model.reconstruct, inputs=inputs,\n samples=samples)\n visualize_reconstruction(inputs, average(reconstruct()))\n visualize_reconstruction(inputs, average(reconstruct(sample_static=True)),\n name=\"static_prior\")\n visualize_reconstruction(inputs, average(reconstruct(sample_dynamic=True)),\n name=\"dynamic_prior\")\n visualize_reconstruction(inputs, average(reconstruct(swap_static=True)),\n name=\"swap_static\")\n visualize_reconstruction(inputs, average(reconstruct(swap_dynamic=True)),\n name=\"swap_dynamic\")\n with tf.compat.v1.name_scope(\"generation\"):\n generate = functools.partial(model.generate, batch_size=batch_size,\n length=length, samples=samples)\n image_summary(average(generate(fix_static=True)), \"fix_static\")\n image_summary(average(generate(fix_dynamic=True)), \"fix_dynamic\")"
340 },
341 {
342 "code": "def debug_script(src, pm=False, globs=None):\n \"Debug a test script. `src` is the script, as a string.\"\n import pdb\n srcfilename = tempfile.mktemp(\".py\", \"doctestdebug\")\n f = open(srcfilename, 'w')\n f.write(src)\n f.close()\n try:\n if globs:\n globs = globs.copy()\n else:\n globs = {}\n if pm:\n try:\n execfile(srcfilename, globs, globs)\n except:\n print sys.exc_info()[1]\n pdb.post_mortem(sys.exc_info()[2])\n else:\n pdb.run(\"execfile(%r)\" % srcfilename, globs, globs)\n finally:\n os.remove(srcfilename)"
343 },
344 {
345 "code": "def _dot_product(self, imgs_to_decode):\n return np.dot(imgs_to_decode.T, self.feature_images).T"
346 },
347 {
348 "code": "def set_certificate_issuer(\n self, vault_base_url, issuer_name, provider, credentials=None, organization_details=None, attributes=None, custom_headers=None, raw=False, **operation_config):\n parameter = models.CertificateIssuerSetParameters(provider=provider, credentials=credentials, organization_details=organization_details, attributes=attributes)\n url = self.set_certificate_issuer.metadata['url']\n path_format_arguments = {\n 'vaultBaseUrl': self._serialize.url(\"vault_base_url\", vault_base_url, 'str', skip_quote=True),\n 'issuer-name': self._serialize.url(\"issuer_name\", issuer_name, 'str')\n }\n url = self._client.format_url(url, **path_format_arguments)\n query_parameters = {}\n query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n header_parameters = {}\n header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n if self.config.generate_client_request_id:\n header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n if custom_headers:\n header_parameters.update(custom_headers)\n if self.config.accept_language is not None:\n header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n body_content = self._serialize.body(parameter, 'CertificateIssuerSetParameters')\n request = self._client.put(url, query_parameters)\n response = self._client.send(\n request, header_parameters, body_content, stream=False, **operation_config)\n if response.status_code not in [200]:\n raise models.KeyVaultErrorException(self._deserialize, response)\n deserialized = None\n if response.status_code == 200:\n deserialized = self._deserialize('IssuerBundle', response)\n if raw:\n client_raw_response = ClientRawResponse(deserialized, response)\n return client_raw_response\n return deserialized"
349 },
350 {
351 "code": "def remove_interval(self, time):\n if self.tier_type != 'IntervalTier':\n raise Exception('Tiertype must be IntervalTier.')\n self.intervals = [i for i in self.intervals\n if not(i[0] <= time and i[1] >= time)]"
352 },
353 {
354 "code": "def _run_valid(self, epoch, valid_set, dry_run=False, save_path=None):\n costs = self.valid_step(valid_set)\n _, J = costs[0]\n new_best = False\n if self.best_cost - J > self.best_cost * self.min_improvement:\n self.best_params = self.copy_params()\n new_best = True\n if not dry_run:\n self.best_cost = J\n self.best_epoch = epoch\n self.save_checkpoint(save_path)\n self.report(dict(costs), type=\"valid\", epoch=0 if dry_run else epoch, new_best=new_best)\n self.last_run_costs = costs\n return epoch - self.best_epoch < self.patience"
355 },
356 {
357 "code": "def Bin(self):\n err = _Bin(self.transit, self.limbdark, self.settings, self.arrays)\n if err != _ERR_NONE: RaiseError(err)"
358 },
359 {
360 "code": "def get_namespaces(self, prefix=None):\n params = {\"prefix\": prefix}\n return self.request(method=\"get\", params=params).json()"
361 },
362 {
363 "code": "def geckoboard_rag_widget(request):\n params = get_gecko_params(request)\n print params['uids']\n max_date = datetime.now()-timedelta(days=params['days_back'])\n metrics = Metric.objects.filter(uid__in=params['uids'])\n results = [(metric.latest_count(frequency=params['frequency'], count=not params['cumulative'],\n cumulative=params['cumulative'], max_date=max_date), metric.title) for metric in metrics]\n return tuple(results)"
364 },
365 {
366 "code": "def _read_compressed_points_data(self, laszip_vlr, point_format):\n offset_to_chunk_table = struct.unpack(\"<q\", self.stream.read(8))[0]\n size_of_point_data = offset_to_chunk_table - self.stream.tell()\n if offset_to_chunk_table <= 0:\n logger.warning(\n \"Strange offset to chunk table: {}, ignoring it..\".format(\n offset_to_chunk_table\n )\n )\n size_of_point_data = -1\n points = record.PackedPointRecord.from_compressed_buffer(\n self.stream.read(size_of_point_data),\n point_format,\n self.header.point_count,\n laszip_vlr,\n )\n return points"
367 },
368 {
369 "code": "def get_system_per_cpu_times():\n ret = []\n for cpu_t in _psutil_mswindows.get_system_cpu_times():\n user, system, idle = cpu_t\n item = _cputimes_ntuple(user, system, idle)\n ret.append(item)\n return ret"
370 },
371 {
372 "code": "def _init_from_bool(self, z, x):\n if z is None:\n raise QiskitError(\"z vector must not be None.\")\n if x is None:\n raise QiskitError(\"x vector must not be None.\")\n if len(z) != len(x):\n raise QiskitError(\"length of z and x vectors must be \"\n \"the same. (z: {} vs x: {})\".format(len(z), len(x)))\n z = _make_np_bool(z)\n x = _make_np_bool(x)\n self._z = z\n self._x = x\n return self"
373 },
374 {
375 "code": "def _expand_default(self, option):\n if self.parser is None or not self.default_tag:\n return option.help\n optname = option._long_opts[0][2:]\n try:\n provider = self.parser.options_manager._all_options[optname]\n except KeyError:\n value = None\n else:\n optdict = provider.get_option_def(optname)\n optname = provider.option_attrname(optname, optdict)\n value = getattr(provider.config, optname, optdict)\n value = utils._format_option_value(optdict, value)\n if value is optparse.NO_DEFAULT or not value:\n value = self.NO_DEFAULT_VALUE\n return option.help.replace(self.default_tag, str(value))"
376 },
377 {
378 "code": "def map(self, func, value_shape=None, dtype=None):\n if value_shape is None or dtype is None:\n try:\n mapped = func(random.randn(*self.plan).astype(self.dtype))\n except Exception:\n first = self._rdd.first()\n if first:\n mapped = func(first[1])\n if value_shape is None:\n value_shape = mapped.shape\n if dtype is None:\n dtype = mapped.dtype\n chunked_dims = where(self.plan != self.vshape)[0]\n unchunked_dims = where(self.plan == self.vshape)[0]\n if len(value_shape) != len(self.plan):\n raise NotImplementedError('map on ChunkedArray cannot drop dimensions')\n if any([value_shape[i] != self.plan[i] for i in chunked_dims]):\n raise ValueError('map cannot change the sizes of chunked dimensions')\n def check_and_apply(v):\n new = func(v)\n if len(unchunked_dims) > 0:\n if any([new.shape[i] != value_shape[i] for i in unchunked_dims]):\n raise Exception(\"Map operation did not produce values of uniform shape.\")\n if len(chunked_dims) > 0:\n if any([v.shape[i] != new.shape[i] for i in chunked_dims]):\n raise Exception(\"Map operation changed the size of a chunked dimension\")\n return new\n rdd = self._rdd.mapValues(check_and_apply)\n vshape = [value_shape[i] if i in unchunked_dims else self.vshape[i] for i in range(len(self.vshape))]\n newshape = r_[self.kshape, vshape].astype(int).tolist()\n return self._constructor(rdd, shape=tuple(newshape), dtype=dtype,\n plan=asarray(value_shape)).__finalize__(self)"
379 },
380 {
381 "code": "def get_data(self, cache=True, as_text=False, parse_form_data=False):\n rv = getattr(self, '_cached_data', None)\n if rv is None:\n if parse_form_data:\n self._load_form_data()\n rv = self.stream.read()\n if cache:\n self._cached_data = rv\n if as_text:\n rv = rv.decode(self.charset, self.encoding_errors)\n return rv"
382 },
383 {
384 "code": "def main(mash_output, sample_id):\n logger.info(\"Reading file : {}\".format(mash_output))\n read_mash_output = open(mash_output)\n dic = {}\n median_list = []\n filtered_dic = {}\n logger.info(\"Generating dictionary and list to pre-process the final json\")\n for line in read_mash_output:\n tab_split = line.split(\"\\t\")\n identity = tab_split[0]\n median_multiplicity = tab_split[2]\n query_id = tab_split[4]\n dic[query_id] = [identity, median_multiplicity]\n median_list.append(float(median_multiplicity))\n output_json = open(\" \".join(mash_output.split(\".\")[:-1]) + \".json\", \"w\")\n if len(median_list) > 0:\n median_cutoff = median(median_list)\n logger.info(\"Generating final json to dump to a file\")\n for k, v in dic.items():\n copy_number = int(float(v[1]) / median_cutoff)\n if float(v[1]) > median_cutoff:\n filtered_dic[\"_\".join(k.split(\"_\")[0:3])] = [\n round(float(v[0]),2),\n copy_number\n ]\n logger.info(\n \"Exported dictionary has {} entries\".format(len(filtered_dic)))\n else:\n logger.error(\"No matches were found using mash screen for the queried reads\")\n output_json.write(json.dumps(filtered_dic))\n output_json.close()\n json_dic = {\n \"tableRow\": [{\n \"sample\": sample_id,\n \"data\": [{\n \"header\": \"Mash Screen\",\n \"table\": \"plasmids\",\n \"patlas_mashscreen\": filtered_dic,\n \"value\": len(filtered_dic)\n }]\n }],\n }\n with open(\".report.json\", \"w\") as json_report:\n json_report.write(json.dumps(json_dic, separators=(\",\", \":\")))"
385 },
386 {
387 "code": "def add_import(\n self, sym: sym.Symbol, module: types.ModuleType, *aliases: sym.Symbol\n ) -> None:\n self._imports.swap(lambda m: m.assoc(sym, module))\n if aliases:\n self._import_aliases.swap(\n lambda m: m.assoc(\n *itertools.chain.from_iterable([(alias, sym) for alias in aliases])\n )\n )"
388 },
389 {
390 "code": "def delete_report(self, report):\n url = ACCOUNTS_API.format(report.account_id) + \"/reports/{}/{}\".format(\n report.type, report.report_id)\n response = self._delete_resource(url)\n return True"
391 },
392 {
393 "code": "def delete(self, blocksize=100):\n from .columns import MODELS_REFERENCED\n if not self._model._no_fk or self._model._namespace in MODELS_REFERENCED:\n raise QueryError(\"Can't delete entities of models with foreign key relationships\")\n de = []\n i = 0\n for result in self.iter_result(pagesize=blocksize):\n de.append(result)\n i += 1\n if i >= blocksize:\n session.delete(de)\n del de[:]\n i = 0\n if de:\n session.delete(de)"
394 },
395 {
396 "code": "def _ep_need_close(self):\n LOG.debug(\"Session %s close requested - closing...\",\n self._name)\n links = self._links.copy()\n for link in links:\n link._session_closed()"
397 },
398 {
399 "code": "def users(store):\n user_objs = list(store.users())\n total_events = store.user_events().count()\n for user_obj in user_objs:\n if user_obj.get('institutes'):\n user_obj['institutes'] = [store.institute(inst_id) for inst_id in user_obj.get('institutes')]\n else:\n user_obj['institutes'] = []\n user_obj['events'] = store.user_events(user_obj).count()\n user_obj['events_rank'] = event_rank(user_obj['events'])\n return dict(\n users=sorted(user_objs, key=lambda user: -user['events']),\n total_events=total_events,\n )"
400 },
401 {
402 "code": "def linear_connection(plist, lane):\n logger.debug(\n \"Establishing linear connection with processes: {}\".format(plist))\n res = []\n previous = None\n for p in plist:\n if not previous:\n previous = p\n continue\n res.append({\n \"input\": {\n \"process\": previous,\n \"lane\": lane\n },\n \"output\": {\n \"process\": p,\n \"lane\": lane\n }\n })\n previous = p\n return res"
403 },
404 {
405 "code": "def run_migrations_online():\n connectable = settings.engine\n with connectable.connect() as connection:\n context.configure(\n connection=connection,\n transaction_per_migration=True,\n target_metadata=target_metadata,\n compare_type=COMPARE_TYPE,\n )\n with context.begin_transaction():\n context.run_migrations()"
406 },
407 {
408 "code": "def map_generic(self, func):\n def process_record(val):\n newval = empty(1, dtype=\"object\")\n newval[0] = func(val)\n return newval\n rdd = self._rdd.mapValues(process_record)\n nchunks = self.getnumber(self.plan, self.vshape)\n newshape = tuple([int(s) for s in r_[self.kshape, nchunks]])\n newsplit = len(self.shape)\n return BoltArraySpark(rdd, shape=newshape, split=newsplit, ordered=self._ordered, dtype=\"object\")"
409 },
410 {
411 "code": "def get_conn(self):\n if not self._conn:\n http_authorized = self._authorize()\n self._conn = build('compute', self.api_version,\n http=http_authorized, cache_discovery=False)\n return self._conn"
412 },
413 {
414 "code": "def parse_args(argv):\n global g_new_messages_to_exclude\n global g_old_messages_to_remove\n global g_load_java_message_filename\n global g_save_java_message_filename\n global g_print_java_messages\n if len(argv) < 2:\n usage()\n i = 1\n while (i < len(argv)):\n s = argv[i]\n if (s == \"--inputfileadd\"):\n i += 1\n if (i > len(argv)):\n usage()\n g_new_messages_to_exclude = argv[i]\n elif (s == \"--inputfilerm\"):\n i += 1\n if (i > len(argv)):\n usage()\n g_old_messages_to_remove = argv[i]\n elif (s == \"--loadjavamessage\"):\n i += 1\n if i > len(argv):\n usage()\n g_load_java_message_filename = argv[i]\n elif (s == \"--savejavamessage\"):\n i += 1\n if (i > len(argv)):\n usage()\n g_save_java_message_filename = argv[i]\n elif (s == '--printjavamessage'):\n i += 1\n g_print_java_messages = True\n g_load_java_message_filename = argv[i]\n elif (s == '--help'):\n usage()\n else:\n unknown_arg(s)\n i += 1"
415 },
416 {
417 "code": "def expand_files(self, modules):\n result, errors = utils.expand_modules(\n modules, self.config.black_list, self.config.black_list_re\n )\n for error in errors:\n message = modname = error[\"mod\"]\n key = error[\"key\"]\n self.set_current_module(modname)\n if key == \"fatal\":\n message = str(error[\"ex\"]).replace(os.getcwd() + os.sep, \"\")\n self.add_message(key, args=message)\n return result"
418 },
419 {
420 "code": "def _m(self):\n assert not hasattr(self, \"_interfaces\") or not self._interfaces, \\\n \"Too late to change direction of interface\"\n self._direction = DIRECTION.asIntfDirection(DIRECTION.opposite(self._masterDir))\n return self"
421 },
422 {
423 "code": "def __nn_filter_helper(R_data, R_indices, R_ptr, S, aggregate):\n s_out = np.empty_like(S)\n for i in range(len(R_ptr)-1):\n targets = R_indices[R_ptr[i]:R_ptr[i+1]]\n if not len(targets):\n s_out[i] = S[i]\n continue\n neighbors = np.take(S, targets, axis=0)\n if aggregate is np.average:\n weights = R_data[R_ptr[i]:R_ptr[i+1]]\n s_out[i] = aggregate(neighbors, axis=0, weights=weights)\n else:\n s_out[i] = aggregate(neighbors, axis=0)\n return s_out"
424 },
425 {
426 "code": "def fit(self, Z, **fit_params):\n Zt, fit_params = self._pre_transform(Z, **fit_params)\n self.steps[-1][-1].fit(Zt, **fit_params)\n Zt.unpersist()\n return self"
427 },
428 {
429 "code": "def _make_content_item(node, mime_type=None, alternate_data=None):\n raw = node.data\n if getattr(node, 'encoding', None) == 'zlib':\n try:\n raw = zlib.decompress(node.data)\n except Exception, exc:\n if alternate_data is not None:\n try:\n raw = zlib.decompress(alternate_data)\n except Exception:\n raise exc\n else:\n raise\n if mime_type is None:\n mime_type = node.mime_type\n raw = raw.decode('utf8').encode('utf8')\n return streamcorpus.ContentItem(raw=raw, media_type=mime_type)"
430 },
431 {
432 "code": "def simUnit(self, synthesisedUnit: Unit, until: float, extraProcesses=[]):\n beforeSim = self.config.beforeSim\n if beforeSim is not None:\n beforeSim(self, synthesisedUnit)\n add_proc = self.add_process\n for p in extraProcesses:\n add_proc(p(self))\n self._initUnitSignals(synthesisedUnit)\n self.run(until)"
433 },
434 {
435 "code": "def parse(self, hcl, canonicalize=False):\n return self.request(\"parse\", json={\"JobHCL\": hcl, \"Canonicalize\": canonicalize}, method=\"post\", allow_redirects=True).json()"
436 },
437 {
438 "code": "def has_no_unchecked_field(self, locator, **kwargs):\n kwargs[\"checked\"] = False\n return self.has_no_selector(\"field\", locator, **kwargs)"
439 },
440 {
441 "code": "def reconnect(self):\n self.log.debug(\"reconnect(): Initialzion reconnect sequence..\")\n self.connected.clear()\n self.reconnect_required.set()\n if self.socket:\n self.socket.close()"
442 },
443 {
444 "code": "def lowpass_filter(data, cutoff, fs, order=5):\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n y = signal.lfilter(b, a, data)\n return y"
445 },
446 {
447 "code": "def _add(self, to_add):\n if PyFunceble.CONFIGURATION[\"mining\"]:\n if PyFunceble.INTERN[\"file_to_test\"] not in PyFunceble.INTERN[\"mined\"]:\n PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]] = {}\n for element in to_add:\n if (\n element\n in PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]]\n ):\n PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n element\n ].extend(to_add[element])\n else:\n PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n element\n ] = to_add[element]\n PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n element\n ] = List(\n PyFunceble.INTERN[\"mined\"][PyFunceble.INTERN[\"file_to_test\"]][\n element\n ]\n ).format()\n self._backup()"
448 },
449 {
450 "code": "def square(duration: int, amp: complex, period: float = None,\n phase: float = 0, name: str = None) -> SamplePulse:\n if period is None:\n period = duration\n return _sampled_square_pulse(duration, amp, period, phase=phase, name=name)"
451 },
452 {
453 "code": "def size(self, train=False, valid=False, xval=False):\n tm = ModelBase._get_metrics(self, train, valid, xval)\n m = {}\n for k, v in tm.items():\n m[k] = None if v is None else [v[2] for v in v._metric_json[\"centroid_stats\"].cell_values]\n return list(m.values())[0] if len(m) == 1 else m"
454 },
455 {
456 "code": "def find_files(filenames, recursive, exclude):\n while filenames:\n name = filenames.pop(0)\n if recursive and os.path.isdir(name):\n for root, directories, children in os.walk(name):\n filenames += [os.path.join(root, f) for f in children\n if match_file(os.path.join(root, f),\n exclude)]\n directories[:] = [d for d in directories\n if match_file(os.path.join(root, d),\n exclude)]\n else:\n if not is_exclude_file(name, exclude):\n yield name"
457 },
458 {
459 "code": "def is_literal_or_name(value):\n try:\n ast.literal_eval(value)\n return True\n except (SyntaxError, ValueError):\n pass\n if value.strip() in ['dict()', 'list()', 'set()']:\n return True\n return re.match(r'^\\w+\\s*$', value)"
460 },
461 {
462 "code": "def complete_restore(\n self, location_name, operation_id, last_backup_name, custom_headers=None, raw=False, polling=True, **operation_config):\n raw_result = self._complete_restore_initial(\n location_name=location_name,\n operation_id=operation_id,\n last_backup_name=last_backup_name,\n custom_headers=custom_headers,\n raw=True,\n **operation_config\n )\n def get_long_running_output(response):\n if raw:\n client_raw_response = ClientRawResponse(None, response)\n return client_raw_response\n lro_delay = operation_config.get(\n 'long_running_operation_timeout',\n self.config.long_running_operation_timeout)\n if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)\n elif polling is False: polling_method = NoPolling()\n else: polling_method = polling\n return LROPoller(self._client, raw_result, get_long_running_output, polling_method)"
463 },
464 {
465 "code": "def post(self, headers={}, body=\"\"):\n code, message = self.command(\"POST\")\n if code != 340:\n raise NNTPReplyError(code, message)\n hdrs = utils.unparse_headers(headers)\n self.socket.sendall(hdrs)\n if isinstance(body, basestring):\n body = cStringIO.StringIO(body)\n illegal = False\n for line in body:\n if line.startswith(\".\"):\n line = \".\" + line\n if line.endswith(\"\\r\\n\"):\n line = line[:-2]\n elif line.endswith(\"\\n\"):\n line = line[:-1]\n if any(c in line for c in \"\\0\\r\"):\n illegal = True\n break\n self.socket.sendall(line + \"\\r\\n\")\n self.socket.sendall(\".\\r\\n\")\n code, message = self.status()\n if illegal:\n raise NNTPDataError(\"Illegal characters found\")\n if code != 240:\n raise NNTPReplyError(code, message)\n message_id = message.split(None, 1)[0]\n if message_id.startswith(\"<\") and message_id.endswith(\">\"):\n return message_id\n return True"
466 },
467 {
468 "code": "def has_context_loop(state, incorrect_msg, exact_names):\n return _test(\n state,\n incorrect_msg or MSG_INCORRECT_LOOP,\n exact_names,\n tv_name=\"_target_vars\",\n highlight_name=\"target\",\n )"
469 },
470 {
471 "code": "def imcrop(img, bboxes, scale=1.0, pad_fill=None):\n chn = 1 if img.ndim == 2 else img.shape[2]\n if pad_fill is not None:\n if isinstance(pad_fill, (int, float)):\n pad_fill = [pad_fill for _ in range(chn)]\n assert len(pad_fill) == chn\n _bboxes = bboxes[None, ...] if bboxes.ndim == 1 else bboxes\n scaled_bboxes = bbox_scaling(_bboxes, scale).astype(np.int32)\n clipped_bbox = bbox_clip(scaled_bboxes, img.shape)\n patches = []\n for i in range(clipped_bbox.shape[0]):\n x1, y1, x2, y2 = tuple(clipped_bbox[i, :])\n if pad_fill is None:\n patch = img[y1:y2 + 1, x1:x2 + 1, ...]\n else:\n _x1, _y1, _x2, _y2 = tuple(scaled_bboxes[i, :])\n if chn == 2:\n patch_shape = (_y2 - _y1 + 1, _x2 - _x1 + 1)\n else:\n patch_shape = (_y2 - _y1 + 1, _x2 - _x1 + 1, chn)\n patch = np.array(\n pad_fill, dtype=img.dtype) * np.ones(\n patch_shape, dtype=img.dtype)\n x_start = 0 if _x1 >= 0 else -_x1\n y_start = 0 if _y1 >= 0 else -_y1\n w = x2 - x1 + 1\n h = y2 - y1 + 1\n patch[y_start:y_start + h, x_start:x_start +\n w, ...] = img[y1:y1 + h, x1:x1 + w, ...]\n patches.append(patch)\n if bboxes.ndim == 1:\n return patches[0]\n else:\n return patches"
472 },
473 {
474 "code": "def validate(self, obj, value):\n try:\n if issubclass(value, self.klass):\n return value\n except:\n if (value is None) and (self._allow_none):\n return value\n self.error(obj, value)"
475 },
476 {
477 "code": "def plot(\n self, data, bbox=None, plot_type='scatter',\n fig_kwargs=None, bmap_kwargs=None, plot_kwargs=None,\n cbar_kwargs=None):\n from mpl_toolkits.basemap import Basemap\n fig_kwargs = fig_kwargs or {}\n bmap_kwargs = bmap_kwargs or {}\n plot_kwargs = plot_kwargs or {}\n cbar_kwargs = cbar_kwargs or {}\n if not bbox:\n bbox = (\n self.nodes_df.y.min(),\n self.nodes_df.x.min(),\n self.nodes_df.y.max(),\n self.nodes_df.x.max())\n fig, ax = plt.subplots(**fig_kwargs)\n bmap = Basemap(\n bbox[1], bbox[0], bbox[3], bbox[2], ax=ax, **bmap_kwargs)\n bmap.drawcoastlines()\n bmap.drawmapboundary()\n x, y = bmap(self.nodes_df.x.values, self.nodes_df.y.values)\n if plot_type == 'scatter':\n plot = bmap.scatter(\n x, y, c=data.values, **plot_kwargs)\n elif plot_type == 'hexbin':\n plot = bmap.hexbin(\n x, y, C=data.values, **plot_kwargs)\n bmap.colorbar(plot, **cbar_kwargs)\n return bmap, fig, ax"
478 },
479 {
480 "code": "def update_configuration(cfgfile=None):\n configobj.DEFAULT_INTERPOLATION = 'template'\n cfgfile = configuration_file(cfgfile)\n cfg = configobj.ConfigObj(cfgfile, configspec=cfgspec, encoding='utf-8')\n validator = Validator()\n val = cfg.validate(validator)\n if val is not True:\n raise ValueError('Invalid configuration: %s' % val)\n if len(cfg['capture']['files']) != len(cfg['capture']['flavors']):\n raise ValueError('List of files and flavors do not match')\n globals()['__config'] = cfg\n logger_init()\n if cfg['server'].get('url', '').endswith('/'):\n logger.warning('Base URL ends with /. This is most likely a '\n 'configuration error. The URL should contain nothing '\n 'of the service paths.')\n logger.info('Configuration loaded from %s' % cfgfile)\n check()\n return cfg"
481 },
482 {
483 "code": "def times_csv(path, times, annotations=None, delimiter=',', fmt='%0.3f'):\n r\n if annotations is not None and len(annotations) != len(times):\n raise ParameterError('len(annotations) != len(times)')\n with open(path, 'w') as output_file:\n writer = csv.writer(output_file, delimiter=delimiter)\n if annotations is None:\n for t in times:\n writer.writerow([fmt % t])\n else:\n for t, lab in zip(times, annotations):\n writer.writerow([(fmt % t), lab])"
484 },
485 {
486 "code": "def add_subgraph(self, info):\n if not info.initialized:\n return\n graph = self._request_graph(info.ui.control)\n if graph is not None:\n subgraph = Subgraph()\n retval = subgraph.edit_traits(parent = info.ui.control,\n kind = \"livemodal\")\n if retval.result:\n graph.subgraphs.append(subgraph)"
487 },
488 {
489 "code": "def _onDeviceStatus(self, client, userdata, pahoMessage):\n try:\n status = Status(pahoMessage)\n self.logger.debug(\"Received %s action from %s\" % (status.action, status.clientId))\n if self.deviceStatusCallback:\n self.deviceStatusCallback(status)\n except InvalidEventException as e:\n self.logger.critical(str(e))"
490 },
491 {
492 "code": "def get_input(prompt, default=None, exit_msg='bye!'):\n try:\n response = six.moves.input(prompt)\n except (KeyboardInterrupt, EOFError):\n print()\n print(exit_msg)\n exit()\n try:\n return int(response)\n except ValueError:\n if response.strip() == \"\" and default is not None:\n return default\n else:\n return response"
493 },
494 {
495 "code": "def encode(self):\n header = bytearray(1)\n varHeader = encode16Int(self.msgId)\n header[0] = 0xB0 \n header.extend(encodeLength(len(varHeader)))\n header.extend(varHeader)\n self.encoded = header\n return str(header) if PY2 else bytes(header)"
496 },
497 {
498 "code": "def set_piece_at(self, square, piece, from_hand=False, into_hand=False):\n if from_hand:\n self.remove_piece_from_hand(piece.piece_type, self.turn)\n self.remove_piece_at(square, into_hand)\n self.pieces[square] = piece.piece_type\n mask = BB_SQUARES[square]\n piece_type = piece.piece_type\n self.piece_bb[piece_type] |= mask\n if piece_type == KING:\n self.king_squares[piece.color] = square\n self.occupied.ixor(mask, piece.color, square)\n if piece.color == BLACK:\n piece_index = (piece.piece_type - 1) * 2\n else:\n piece_index = (piece.piece_type - 1) * 2 + 1\n self.incremental_zobrist_hash ^= DEFAULT_RANDOM_ARRAY[81 * piece_index + 9 * rank_index(square) + file_index(square)]"
499 },
500 {
501 "code": "def _check_relative_import(\n self, modnode, importnode, importedmodnode, importedasname\n ):\n if not self.linter.is_message_enabled(\"relative-import\"):\n return None\n if importedmodnode.file is None:\n return False\n if modnode is importedmodnode:\n return False\n if modnode.absolute_import_activated() or getattr(importnode, \"level\", None):\n return False\n if importedmodnode.name != importedasname:\n self.add_message(\n \"relative-import\",\n args=(importedasname, importedmodnode.name),\n node=importnode,\n )\n return None\n return None"
502 },
503 {
504 "code": "def sold_out_and_unregistered(context):\n user = user_for_context(context)\n if hasattr(user, \"attendee\") and user.attendee.completed_registration:\n return None\n ticket_category = settings.TICKET_PRODUCT_CATEGORY\n categories = available_categories(context)\n return ticket_category not in [cat.id for cat in categories]"
505 },
506 {
507 "code": "def is_token_from_emulator(auth_header: str) -> bool:\n if not auth_header:\n return False\n parts = auth_header.split(' ')\n if len(parts) != 2:\n return False\n auth_scheme = parts[0]\n bearer_token = parts[1]\n if auth_scheme != 'Bearer':\n return False\n token = jwt.decode(bearer_token, verify=False)\n if not token:\n return False\n issuer = token['iss']\n if not issuer:\n return False\n issuer_list = EmulatorValidation.TO_BOT_FROM_EMULATOR_TOKEN_VALIDATION_PARAMETERS.issuer\n if issuer_list and not issuer in issuer_list:\n return False\n return True"
508 },
509 {
510 "code": "def render_template(template_file, dst_file, **kwargs):\n with open(template_file) as f:\n template_text = f.read()\n dst_text = template_text\n for key, value in kwargs.iteritems():\n dst_text = dst_text .replace(\"{{\" + key + \"}}\", value)\n with open(dst_file, \"wt\") as f:\n f.write(dst_text)"
511 },
512 {
513 "code": "def is_subdomain(self, domain=None):\n if domain:\n to_test = domain\n elif self.element:\n to_test = self.element\n else:\n to_test = PyFunceble.INTERN[\"to_test\"]\n return self.is_domain_valid(to_test, subdomain_check=True)"
514 },
515 {
516 "code": "def make_logging_handlers_and_tools(self, multiproc=False):\n log_stdout = self.log_stdout\n if sys.stdout is self._stdout_to_logger:\n log_stdout = False\n if self.log_config:\n if multiproc:\n proc_log_config = self._mp_config\n else:\n proc_log_config = self._sp_config\n if proc_log_config:\n if isinstance(proc_log_config, dict):\n new_dict = self._handle_dict_config(proc_log_config)\n dictConfig(new_dict)\n else:\n parser = self._handle_config_parsing(proc_log_config)\n memory_file = self._parser_to_string_io(parser)\n fileConfig(memory_file, disable_existing_loggers=False)\n if log_stdout:\n std_name, std_level = self.log_stdout\n stdout = StdoutToLogger(std_name, log_level=std_level)\n stdout.start()\n self._tools.append(stdout)"
517 },
518 {
519 "code": "def _get_index_urls_locations(self, project_name):\n def mkurl_pypi_url(url):\n loc = posixpath.join(url, project_url_name)\n if not loc.endswith('/'):\n loc = loc + '/'\n return loc\n project_url_name = urllib_parse.quote(project_name.lower())\n if self.index_urls:\n main_index_url = Link(\n mkurl_pypi_url(self.index_urls[0]),\n trusted=True,\n )\n page = self._get_page(main_index_url)\n if page is None and PyPI.netloc not in str(main_index_url):\n warnings.warn(\n \"Failed to find %r at %s. It is suggested to upgrade \"\n \"your index to support normalized names as the name in \"\n \"/simple/{name}.\" % (project_name, main_index_url),\n RemovedInPip8Warning,\n )\n project_url_name = self._find_url_name(\n Link(self.index_urls[0], trusted=True),\n project_url_name,\n ) or project_url_name\n if project_url_name is not None:\n return [mkurl_pypi_url(url) for url in self.index_urls]\n return []"
520 },
521 {
522 "code": "def _setup_logging(self, log_level: str):\n level = getattr(logging, log_level)\n names = (\n 'aiohttp.access', 'aiohttp.internal', 'aiohttp.server',\n 'aiohttp.web', self.name)\n for name in names:\n setup_logger(name=name, stream=sys.stderr, level=level)"
523 },
524 {
525 "code": "def parse(self, selector):\n log.debug(self.obj)\n tokens = lex(selector)\n if self.peek(tokens, 'operator') == '*':\n self.match(tokens, 'operator')\n results = list(object_iter(self.obj))\n else:\n results = self.selector_production(tokens)\n results = [node.value for node in results]\n if len(results) == 1:\n return results[0]\n elif not len(results):\n return None\n return results"
526 },
527 {
528 "code": "def bandpass_filter(data, low, high, fs, order=5):\n nyq = 0.5 * fs\n low = low / nyq\n high = high / nyq\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data)\n return y"
529 },
530 {
531 "code": "def build_schema(m, c_c):\n schema = ET.Element('xs:schema')\n schema.set('xmlns:xs', 'http://www.w3.org/2001/XMLSchema')\n global_filter = lambda selected: ooaofooa.is_global(selected)\n for s_dt in m.select_many('S_DT', global_filter):\n datatype = build_type(s_dt)\n if datatype is not None:\n schema.append(datatype)\n scope_filter = lambda selected: ooaofooa.is_contained_in(selected, c_c)\n for s_dt in m.select_many('S_DT', scope_filter):\n datatype = build_type(s_dt)\n if datatype is not None:\n schema.append(datatype)\n component = build_component(m, c_c)\n schema.append(component)\n return schema"
532 },
533 {
534 "code": "def execute(option):\n namelist_option = []\n makefile_option = []\n flags = \"\"\n for entry in option:\n key = entry.keys()[0]\n if key == \"Problem Size\":\n namelist_option.append({\"SIZE\": entry[key]})\n elif key == \"F90\":\n makefile_option.append(entry)\n else:\n flags += entry[key] + \" \"\n makefile_option.append({\"F90FLAGS\": flags})\n namelist = create_input(namelist_option, \"namelist\",\n template_location=\"templates\")\n makefile_include = create_input(makefile_option, \"Makefile.include\",\n template_location=\"templates\")\n benchmark_base = \"shallow\"\n location = benchmark_base + \"/original/namelist\"\n my_file = open(location, 'w')\n my_file.write(namelist)\n my_file.flush()\n location = benchmark_base + \"/common/Makefile.include\"\n my_file = open(location, 'w')\n my_file.write(makefile_include)\n my_file.flush()\n base_path = benchmark_base + \"/original\"\n import subprocess\n make_process = subprocess.Popen([\"make\", \"clean\"], cwd=base_path,\n stderr=subprocess.PIPE,\n stdout=subprocess.PIPE)\n if make_process.wait() != 0:\n return False, []\n make_process = subprocess.Popen([\"make\"], cwd=base_path,\n stderr=subprocess.PIPE,\n stdout=subprocess.PIPE)\n if make_process.wait() != 0:\n return False, []\n make_process = subprocess.Popen([\"./shallow_base\"], cwd=base_path,\n stderr=subprocess.PIPE,\n stdout=subprocess.PIPE)\n if make_process.wait() != 0:\n return False, []\n stdout = make_process.stdout.read()\n for line in stdout.split(\"\\n\"):\n if \"Time-stepping\" in line:\n total_time = line.split()[2]\n return True, total_time"
535 },
536 {
537 "code": "def img_from_vgg(x):\n x = x.transpose((1, 2, 0))\n x[:, :, 0] += 103.939\n x[:, :, 1] += 116.779\n x[:, :, 2] += 123.68\n x = x[:,:,::-1]\n return x"
538 },
539 {
540 "code": "def remove_unique_identifiers(identifiers_to_tags, pipeline_links):\n for index, val in enumerate(pipeline_links):\n if val[\"input\"][\"process\"] != \"__init__\":\n val[\"input\"][\"process\"] = identifiers_to_tags[\n val[\"input\"][\"process\"]]\n if val[\"output\"][\"process\"] != \"__init__\":\n val[\"output\"][\"process\"] = identifiers_to_tags[\n val[\"output\"][\"process\"]]\n return pipeline_links"
541 },
542 {
543 "code": "def fetch_items(self, category, **kwargs):\n from_date = kwargs['from_date']\n if self.client.version[0] == 2 and self.client.version[1] == 8:\n fetcher = self._fetch_gerrit28(from_date)\n else:\n fetcher = self._fetch_gerrit(from_date)\n for review in fetcher:\n yield review"
544 },
545 {
546 "code": "def _imported_module(self, node, mod_path, relative):\n module = node.root()\n context_name = module.name\n if relative:\n mod_path = \"%s.%s\" % (\".\".join(context_name.split(\".\")[:-1]), mod_path)\n if self.compute_module(context_name, mod_path):\n if not hasattr(module, \"depends\"):\n module.depends = []\n mod_paths = module.depends\n if mod_path not in mod_paths:\n mod_paths.append(mod_path)"
547 },
548 {
549 "code": "def _get_existing_instance(self, query, value):\n if self.columns:\n result = query.filter_by(\n **{prop.key: value.get(prop.key) for prop in self.related_keys}\n ).one()\n else:\n result = query.get([value.get(prop.key) for prop in self.related_keys])\n if result is None:\n raise NoResultFound\n return result"
550 },
551 {
552 "code": "def deprecated(*args):\n def wrap(func):\n def wrapped_func(*args, **kwargs):\n warnings.warn(msg, category=DeprecationWarning)\n return func(*args, **kwargs)\n return wrapped_func\n if len(args) == 1 and callable(args[0]):\n msg = \"Function '%s' will be deprecated in future versions of \" \\\n \"Neurosynth.\" % args[0].__name__\n return wrap(args[0])\n else:\n msg = args[0]\n return wrap"
553 },
554 {
555 "code": "def _get_required_args(fn):\n argspec = tf_inspect.getfullargspec(fn)\n args = argspec.args\n if tf_inspect.isclass(fn):\n args = args[1:]\n if argspec.defaults:\n args = args[:-len(argspec.defaults)]\n return tuple(args)"
556 },
557 {
558 "code": "def compute_lst(self):\n if self.header[b'telescope_id'] == 6:\n self.coords = gbt_coords\n elif self.header[b'telescope_id'] == 4:\n self.coords = parkes_coords\n else:\n raise RuntimeError(\"Currently only Parkes and GBT supported\")\n if HAS_SLALIB:\n dut1 = 0.0\n mjd = self.header[b'tstart']\n tellong = np.deg2rad(self.coords[1])\n last = s.sla_gmst(mjd) - tellong + s.sla_eqeqx(mjd) + dut1\n if last < 0.0 : last = last + 2.0*np.pi\n return last\n else:\n raise RuntimeError(\"This method requires pySLALIB\")"
559 },
560 {
561 "code": "def register_metric(metric_name: str) -> Callable[..., Any]:\n def decorate(fn):\n fn_name = fn.__module__ + ':' + fn.__name__\n if metric_name in _REGISTRY and _REGISTRY[metric_name] != fn_name:\n log.warning('\"{}\" is already registered as a metric name, the old function will be ignored'\n .format(metric_name))\n _REGISTRY[metric_name] = fn_name\n return fn\n return decorate"
562 },
563 {
564 "code": "def _check_type(var, vtype):\n if vtype is None:\n return var is None\n if isinstance(vtype, _primitive_type):\n return var == vtype\n if vtype is str:\n return isinstance(var, _str_type)\n if vtype is int:\n return isinstance(var, _int_type)\n if vtype is numeric:\n return isinstance(var, _num_type)\n if isinstance(vtype, MagicType):\n return vtype.check(var)\n if isinstance(vtype, type):\n return isinstance(var, vtype)\n if isinstance(vtype, list):\n elem_type = U(*vtype)\n return isinstance(var, list) and all(_check_type(item, elem_type) for item in var)\n if isinstance(vtype, set):\n elem_type = U(*vtype)\n return isinstance(var, set) and all(_check_type(item, elem_type) for item in var)\n if isinstance(vtype, tuple):\n return (isinstance(var, tuple) and len(vtype) == len(var) and\n all(_check_type(var[i], vtype[i]) for i in range(len(vtype))))\n if isinstance(vtype, dict):\n ttkv = U(*viewitems(vtype))\n return isinstance(var, dict) and all(_check_type(kv, ttkv) for kv in viewitems(var))\n if isinstance(vtype, (FunctionType, BuiltinFunctionType)):\n return vtype(var)\n raise RuntimeError(\"Ivalid type %r in _check_type()\" % vtype)"
565 },
566 {
567 "code": "def _basilisp_bytecode(\n mtime: int, source_size: int, code: List[types.CodeType]\n) -> bytes:\n data = bytearray(MAGIC_NUMBER)\n data.extend(_w_long(mtime))\n data.extend(_w_long(source_size))\n data.extend(marshal.dumps(code))\n return data"
568 },
569 {
570 "code": "def select_name_pattern(source, pat):\n return filter(lambda x: pat.match(x.xml_name) is not None, select_elements(source))"
571 },
572 {
573 "code": "def get_overrides_filename(variable):\n filename = os.environ.get(variable)\n if filename is None:\n msg = 'Please set the {} environment variable.'.format(variable)\n raise EnvironmentError(msg)\n return filename"
574 },
575 {
576 "code": "def get_order(self, order_id):\n resp = self.get('/orders/{}'.format(order_id))\n return Order(resp)"
577 },
578 {
579 "code": "def networkdays(from_date, to_date, locale='en-US'):\n holidays = locales[locale]\n return workdays.networkdays(from_date, to_date, holidays)"
580 },
581 {
582 "code": "def start_proxy(self):\n self._download_sql_proxy_if_needed()\n if self.sql_proxy_process:\n raise AirflowException(\"The sql proxy is already running: {}\".format(\n self.sql_proxy_process))\n else:\n command_to_run = [self.sql_proxy_path]\n command_to_run.extend(self.command_line_parameters)\n try:\n self.log.info(\"Creating directory %s\",\n self.cloud_sql_proxy_socket_directory)\n os.makedirs(self.cloud_sql_proxy_socket_directory)\n except OSError:\n pass\n command_to_run.extend(self._get_credential_parameters())\n self.log.info(\"Running the command: `%s`\", \" \".join(command_to_run))\n self.sql_proxy_process = Popen(command_to_run,\n stdin=PIPE, stdout=PIPE, stderr=PIPE)\n self.log.info(\"The pid of cloud_sql_proxy: %s\", self.sql_proxy_process.pid)\n while True:\n line = self.sql_proxy_process.stderr.readline().decode('utf-8')\n return_code = self.sql_proxy_process.poll()\n if line == '' and return_code is not None:\n self.sql_proxy_process = None\n raise AirflowException(\n \"The cloud_sql_proxy finished early with return code {}!\".format(\n return_code))\n if line != '':\n self.log.info(line)\n if \"googleapi: Error\" in line or \"invalid instance name:\" in line:\n self.stop_proxy()\n raise AirflowException(\n \"Error when starting the cloud_sql_proxy {}!\".format(\n line))\n if \"Ready for new connections\" in line:\n return"
583 },
584 {
585 "code": "def init_role(self, role_name, role_vms, role_perms):\n pvms = self.get_session.query(sqla_models.PermissionView).all()\n pvms = [p for p in pvms if p.permission and p.view_menu]\n role = self.find_role(role_name)\n if not role:\n role = self.add_role(role_name)\n if len(role.permissions) == 0:\n self.log.info('Initializing permissions for role:%s in the database.', role_name)\n role_pvms = set()\n for pvm in pvms:\n if pvm.view_menu.name in role_vms and pvm.permission.name in role_perms:\n role_pvms.add(pvm)\n role.permissions = list(role_pvms)\n self.get_session.merge(role)\n self.get_session.commit()\n else:\n self.log.debug('Existing permissions for the role:%s '\n 'within the database will persist.', role_name)"
586 },
587 {
588 "code": "def glm(interactive=True, echo=True, testing=False):\n def demo_body(go):\n go()\n h2o.init()\n go()\n prostate = h2o.load_dataset(\"prostate\")\n go()\n prostate.describe()\n go()\n train, test = prostate.split_frame(ratios=[0.70])\n go()\n train[\"CAPSULE\"] = train[\"CAPSULE\"].asfactor()\n test[\"CAPSULE\"] = test[\"CAPSULE\"].asfactor()\n go()\n from h2o.estimators import H2OGeneralizedLinearEstimator\n prostate_glm = H2OGeneralizedLinearEstimator(family=\"binomial\", alpha=[0.5])\n prostate_glm.train(x=[\"AGE\", \"RACE\", \"PSA\", \"VOL\", \"GLEASON\"],\n y=\"CAPSULE\", training_frame=train)\n go()\n prostate_glm.show()\n go()\n predictions = prostate_glm.predict(test)\n predictions.show()\n go()\n performance = prostate_glm.model_performance(test)\n performance.show()\n _run_demo(demo_body, interactive, echo, testing)"
589 },
590 {
591 "code": "def dsync_handler(self, args):\n self.opt.recursive = True\n self.opt.sync_check = True\n self.opt.force = True\n self.validate('cmd|s3,local|s3,local', args)\n source = args[1]\n target = args[2]\n self.s3handler().dsync_files(source, target)"
592 },
593 {
594 "code": "def mkstemp(self, suffix, prefix, directory=None):\n if not directory:\n directory = self.artifacts_dir\n fd, fname = tempfile.mkstemp(suffix, prefix, directory)\n os.close(fd)\n os.chmod(fname, 0o644)\n return fname"
595 },
596 {
597 "code": "def patch_protocol_for_agent(protocol):\n old_makeConnection = protocol.makeConnection\n old_connectionLost = protocol.connectionLost\n def new_makeConnection(transport):\n patch_transport_fake_push_producer(transport)\n patch_transport_abortConnection(transport, protocol)\n return old_makeConnection(transport)\n def new_connectionLost(reason):\n if protocol._fake_connection_aborted and reason.check(ConnectionDone):\n reason = Failure(ConnectionAborted())\n return old_connectionLost(reason)\n protocol.makeConnection = new_makeConnection\n protocol.connectionLost = new_connectionLost\n protocol._fake_connection_aborted = False"
598 },
599 {
600 "code": "def cinder(*arg):\n check_event_type(Openstack.Cinder, *arg)\n event_type = arg[0]\n def decorator(func):\n if event_type.find(\"*\") != -1:\n event_type_pattern = pre_compile(event_type)\n cinder_customer_process_wildcard[event_type_pattern] = func\n else:\n cinder_customer_process[event_type] = func\n log.info(\"add function {0} to process event_type:{1}\".format(func.__name__, event_type))\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n func(*args, **kwargs)\n return wrapper\n return decorator"
601 },
602 {
603 "code": "def formalize(self):\n source_class = self.source_link.to_metaclass\n target_class = self.target_link.to_metaclass\n source_class.referential_attributes |= set(self.source_keys)\n target_class.identifying_attributes |= set(self.target_keys)\n def fget(inst, ref_name, alt_prop):\n other_inst = self.target_link.navigate_one(inst)\n if other_inst is None and alt_prop:\n return alt_prop.fget(inst)\n return getattr(other_inst, ref_name, None)\n def fset(inst, value, name, ref_name, alt_prop):\n kind = get_metaclass(inst).kind\n raise MetaException('%s.%s is a referential attribute '\\\n 'and cannot be assigned directly'% (kind, name))\n for ref_key, primary_key in zip(self.source_keys, self.target_keys):\n prop = getattr(source_class.clazz, ref_key, None)\n prop = property(partial(fget, ref_name=primary_key, alt_prop=prop), \n partial(fset, name=ref_key, ref_name=primary_key, alt_prop=prop))\n setattr(source_class.clazz, ref_key, prop)"
604 },
605 {
606 "code": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):\n local_stream = utils.BytearrayStream()\n if self._unique_identifier:\n self._unique_identifier.write(\n local_stream,\n kmip_version=kmip_version\n )\n if self._cryptographic_parameters:\n self._cryptographic_parameters.write(\n local_stream,\n kmip_version=kmip_version\n )\n if self._data:\n self._data.write(local_stream, kmip_version=kmip_version)\n if self._digested_data:\n self._digested_data.write(local_stream, kmip_version=kmip_version)\n if self._signature_data:\n self._signature_data.write(\n local_stream,\n kmip_version=kmip_version\n )\n if self._correlation_value:\n self._correlation_value.write(\n local_stream,\n kmip_version=kmip_version\n )\n if self._init_indicator:\n self._init_indicator.write(\n local_stream,\n kmip_version=kmip_version\n )\n if self._final_indicator:\n self._final_indicator.write(\n local_stream,\n kmip_version=kmip_version\n )\n self.length = local_stream.length()\n super(SignatureVerifyRequestPayload, self).write(\n output_stream,\n kmip_version=kmip_version\n )\n output_stream.write(local_stream.buffer)"
607 },
608 {
609 "code": "def get_imap_capabilities(server):\n capabilities = list(map(str, list(server.capabilities())))\n for i in range(len(capabilities)):\n capabilities[i] = str(capabilities[i]).replace(\"b'\",\n \"\").replace(\"'\",\n \"\")\n logger.debug(\"IMAP server supports: {0}\".format(capabilities))\n return capabilities"
610 },
611 {
612 "code": "def get_prices(self, date: str, currency: str) -> List[PriceModel]:\n from .repositories import PriceRepository\n session = self.session\n repo = PriceRepository(session)\n query = repo.query\n if date:\n query = query.filter(dal.Price.date == date)\n if currency:\n query = query.filter(dal.Price.currency == currency)\n query = query.order_by(dal.Price.namespace, dal.Price.symbol)\n price_entities = query.all()\n mapper = mappers.PriceMapper()\n result = []\n for entity in price_entities:\n model = mapper.map_entity(entity)\n result.append(model)\n return result"
613 },
614 {
615 "code": "def _handle_display_data(self, msg):\n self.log.debug(\"display: %s\", msg.get('content', ''))\n if not self._hidden and self._is_from_this_session(msg):\n source = msg['content']['source']\n data = msg['content']['data']\n metadata = msg['content']['metadata']\n if data.has_key('text/html'):\n html = data['text/html']\n self._append_html(html, True)\n elif data.has_key('text/plain'):\n text = data['text/plain']\n self._append_plain_text(text, True)\n self._append_plain_text(u'\\n', True)"
616 },
617 {
618 "code": "def check_type(self, value):\n if self.__dict__['dtype'] is None:\n return\n elif value is None:\n return\n elif isinstance(value, self.__dict__['dtype']):\n return\n msg = \"Value of type %s, when %s was expected.\" % (\n type(value), self.__dict__['dtype'])\n raise TypeError(msg)"
619 },
620 {
621 "code": "def s3walk(self, basedir, show_dir=None):\n if not show_dir:\n show_dir = self.opt.show_dir\n if basedir[-1] == PATH_SEP:\n basedir = basedir[0:-1]\n s3url = S3URL(basedir)\n result = []\n pool = ThreadPool(ThreadUtil, self.opt)\n pool.s3walk(s3url, s3url.get_fixed_path(), s3url.path, result)\n pool.join()\n if not show_dir and len(result) == 1 and result[0]['is_dir']:\n path = result[0]['name']\n s3url = S3URL(path)\n result = []\n pool = ThreadPool(ThreadUtil, self.opt)\n pool.s3walk(s3url, s3url.get_fixed_path(), s3url.path, result)\n pool.join()\n def compare(x, y):\n result = -cmp(x['is_dir'], y['is_dir'])\n if result != 0:\n return result\n return cmp(x['name'], y['name'])\n return sorted(result, key=cmp_to_key(compare))"
622 },
623 {
624 "code": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):\n local_buffer = utils.BytearrayStream()\n if self._unique_identifier:\n self._unique_identifier.write(\n local_buffer,\n kmip_version=kmip_version\n )\n self.length = local_buffer.length()\n super(GetAttributeListRequestPayload, self).write(\n output_buffer,\n kmip_version=kmip_version\n )\n output_buffer.write(local_buffer.buffer)"
625 },
626 {
627 "code": "def _construct_schema(elements, nsmap):\n schema = {\n 'properties': {},\n 'geometry': None\n }\n schema_key = None\n gml_key = None\n if nsmap:\n for key in nsmap:\n if nsmap[key] == XS_NAMESPACE:\n schema_key = key\n if nsmap[key] in GML_NAMESPACES:\n gml_key = key\n else:\n gml_key = 'gml'\n schema_key = 'xsd'\n mappings = {\n 'PointPropertyType': 'Point',\n 'PolygonPropertyType': 'Polygon',\n 'LineStringPropertyType': 'LineString',\n 'MultiPointPropertyType': 'MultiPoint',\n 'MultiLineStringPropertyType': 'MultiLineString',\n 'MultiPolygonPropertyType': 'MultiPolygon',\n 'MultiGeometryPropertyType': 'MultiGeometry',\n 'GeometryPropertyType': 'GeometryCollection',\n 'SurfacePropertyType': '3D Polygon',\n 'MultiSurfacePropertyType': '3D MultiPolygon'\n }\n for element in elements:\n data_type = element.attrib['type'].replace(gml_key + ':', '')\n name = element.attrib['name']\n if data_type in mappings:\n schema['geometry'] = mappings[data_type]\n schema['geometry_column'] = name\n else:\n schema['properties'][name] = data_type.replace(schema_key+':', '')\n if schema['properties'] or schema['geometry']:\n return schema\n else:\n return None"
628 },
629 {
630 "code": "def _exit_gracefully(self, signum, frame):\n self.log.info(\"Exiting gracefully upon receiving signal %s\", signum)\n self.terminate()\n self.end()\n self.log.debug(\"Finished terminating DAG processors.\")\n sys.exit(os.EX_OK)"
631 },
632 {
633 "code": "def convertArgsToTokens(self, data):\n tdict = []\n tokens = []\n d = open(data, 'r')\n for line in d.readlines():\n tdict.append(line.rstrip())\n tokens += line.split()\n d.close()\n tokens = list(set(tokens))\n return tdict, tokens"
634 },
635 {
636 "code": "def _nested_convert_to_tensor(struct, dtype=None, name=None):\n if dtype is not None or not tf.nest.is_nested(struct):\n return tf.convert_to_tensor(struct, dtype=dtype)\n if _maybe_convertible_to_tensor(struct):\n try:\n return tf.convert_to_tensor(value=struct, name=name)\n except (ValueError, TypeError):\n pass\n shallow_struct = _get_shallow_structure(struct)\n return nest.map_structure_up_to(\n shallow_struct, lambda s: _nested_convert_to_tensor(s, name=name), struct)"
637 },
638 {
639 "code": "def __get_or_create(\n ns_cache: NamespaceMap,\n name: sym.Symbol,\n module: types.ModuleType = None,\n core_ns_name=CORE_NS,\n ) -> lmap.Map:\n ns = ns_cache.entry(name, None)\n if ns is not None:\n return ns_cache\n new_ns = Namespace(name, module=module)\n if name.name != core_ns_name:\n core_ns = ns_cache.entry(sym.symbol(core_ns_name), None)\n assert core_ns is not None, \"Core namespace not loaded yet!\"\n new_ns.refer_all(core_ns)\n return ns_cache.assoc(name, new_ns)"
640 },
641 {
642 "code": "def gauss(x, *p):\n A, mu, sigma = p\n return A * np.exp(-0.5 * (-mu + x)**2 / sigma**2)"
643 },
644 {
645 "code": "def tempfile_set(tempfile, target):\n if target:\n os.rename(tempfile, target)\n else:\n os.unlink(tempfile)\n if target in TEMP_FILES:\n TEMP_FILES.remove(tempfile)"
646 },
647 {
648 "code": "def _get_properties(config):\n property_classes = {BUILTIN_PROPERTY}\n property_names = set()\n if config is not None:\n property_classes.update(config.property_classes)\n property_names.update(\n (prop.rsplit(\".\", 1)[-1] for prop in config.property_classes)\n )\n return property_classes, property_names"
649 },
650 {
651 "code": "def duration(self):\n ecc = self.ecc if not np.isnan(self.ecc) else np.sqrt(self.ecw**2 + self.esw**2)\n esw = self.esw if not np.isnan(self.esw) else ecc * np.sin(self.w)\n aRs = ((G * self.rhos * (1. + self.MpMs) * \n (self.per * DAYSEC)**2.) / (3. * np.pi))**(1./3.)\n inc = np.arccos(self.bcirc/aRs)\n becc = self.bcirc * (1 - ecc**2)/(1 - esw)\n tdur = self.per / 2. / np.pi * np.arcsin(((1. + self.RpRs)**2 -\n becc**2)**0.5 / (np.sin(inc) * aRs))\n tdur *= np.sqrt(1. - ecc**2.)/(1. - esw)\n return tdur"
652 },
653 {
654 "code": "def __fetch_items(self, path, page=1):\n fetch_data = True\n parsed_crates = 0\n total_crates = 0\n while fetch_data:\n logger.debug(\"Fetching page: %i\", page)\n try:\n payload = {'sort': 'alphabetical', 'page': page}\n raw_content = self.fetch(path, payload=payload)\n content = json.loads(raw_content)\n parsed_crates += len(content['crates'])\n if not total_crates:\n total_crates = content['meta']['total']\n except requests.exceptions.HTTPError as e:\n logger.error(\"HTTP exception raised - %s\", e.response.text)\n raise e\n yield raw_content\n page += 1\n if parsed_crates >= total_crates:\n fetch_data = False"
655 },
656 {
657 "code": "def _joint_mean(self):\n with tf.name_scope(\"mean_joint\"):\n with tf.control_dependencies(self.runtime_assertions):\n initial_latent_mean = _broadcast_to_shape(\n self.initial_state_prior.mean()[..., tf.newaxis],\n tf.concat([self.batch_shape_tensor(),\n [self.latent_size, 1]], axis=0))\n initial_observation_mean = _propagate_mean(\n initial_latent_mean,\n self.get_observation_matrix_for_timestep(self.initial_step),\n self.get_observation_noise_for_timestep(self.initial_step))\n mean_step = build_kalman_mean_step(\n self.get_transition_matrix_for_timestep,\n self.get_transition_noise_for_timestep,\n self.get_observation_matrix_for_timestep,\n self.get_observation_noise_for_timestep)\n (latent_means, observation_means) = tf.scan(\n mean_step,\n elems=tf.range(self.initial_step+1, self.final_step),\n initializer=(initial_latent_mean, initial_observation_mean))\n latent_means = tf.concat([initial_latent_mean[tf.newaxis, ...],\n latent_means], axis=0)\n observation_means = tf.concat([initial_observation_mean[tf.newaxis, ...],\n observation_means], axis=0)\n latent_means = tf.squeeze(latent_means, -1)\n latent_means = distribution_util.move_dimension(latent_means, 0, -2)\n observation_means = tf.squeeze(observation_means, -1)\n observation_means = distribution_util.move_dimension(\n observation_means, 0, -2)\n return latent_means, observation_means"
658 },
659 {
660 "code": "def resolve_outputs(self):\n input_shape = None\n for i, shape in enumerate(self._input_shapes.values()):\n if i == 0:\n input_shape = shape\n if len(input_shape) != len(shape) or any(\n a is not None and b is not None and a != b\n for a, b in zip(input_shape[:-1], shape[:-1])):\n raise util.ConfigurationError(\n 'layer \"{}\" incompatible input shapes {}'\n .format(self.name, self._input_shapes))\n size = self.kwargs.get('size')\n shape = self.kwargs.get('shape')\n if shape is not None:\n pass\n elif size is not None:\n shape = tuple(input_shape[:-1]) + (size, )\n else:\n raise util.ConfigurationError(\n 'layer \"{}\" does not specify a size'.format(self.name))\n self._output_shapes['out'] = shape"
661 },
662 {
663 "code": "def read(self, filename):\n kwargs = {}\n if sys.version_info >= (3, 2):\n kwargs['encoding'] = \"utf-8\"\n return configparser.RawConfigParser.read(self, filename, **kwargs)"
664 },
665 {
666 "code": "def normalize(self, dt, is_dst=False):\n if dt.tzinfo is None:\n raise ValueError('Naive time - no tzinfo set')\n return dt.replace(tzinfo=self)"
667 },
668 {
669 "code": "def close(self):\n if self._closed:\n return\n self._socket.close()\n self._closed = True"
670 },
671 {
672 "code": "def add_patches(self, patches, after=None):\n if after is None:\n self.insert_patches(patches)\n else:\n self._check_patch(after)\n patchlines = self._patchlines_before(after)\n patchlines.append(self.patch2line[after])\n for patch in patches:\n patchline = PatchLine(patch)\n patchlines.append(patchline)\n self.patch2line[patchline.get_patch()] = patchline\n patchlines.extend(self._patchlines_after(after))\n self.patchlines = patchlines"
673 },
674 {
675 "code": "def update_key(\n self, vault_base_url, key_name, key_version, key_ops=None, key_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):\n parameters = models.KeyUpdateParameters(key_ops=key_ops, key_attributes=key_attributes, tags=tags)\n url = self.update_key.metadata['url']\n path_format_arguments = {\n 'vaultBaseUrl': self._serialize.url(\"vault_base_url\", vault_base_url, 'str', skip_quote=True),\n 'key-name': self._serialize.url(\"key_name\", key_name, 'str'),\n 'key-version': self._serialize.url(\"key_version\", key_version, 'str')\n }\n url = self._client.format_url(url, **path_format_arguments)\n query_parameters = {}\n query_parameters['api-version'] = self._serialize.query(\"self.api_version\", self.api_version, 'str')\n header_parameters = {}\n header_parameters['Content-Type'] = 'application/json; charset=utf-8'\n if self.config.generate_client_request_id:\n header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())\n if custom_headers:\n header_parameters.update(custom_headers)\n if self.config.accept_language is not None:\n header_parameters['accept-language'] = self._serialize.header(\"self.config.accept_language\", self.config.accept_language, 'str')\n body_content = self._serialize.body(parameters, 'KeyUpdateParameters')\n request = self._client.patch(url, query_parameters)\n response = self._client.send(\n request, header_parameters, body_content, stream=False, **operation_config)\n if response.status_code not in [200]:\n raise models.KeyVaultErrorException(self._deserialize, response)\n deserialized = None\n if response.status_code == 200:\n deserialized = self._deserialize('KeyBundle', response)\n if raw:\n client_raw_response = ClientRawResponse(deserialized, response)\n return client_raw_response\n return deserialized"
676 },
677 {
678 "code": "def specific_gains(string):\n if not string:\n return {}\n gains = {}\n for gain in string.split(','):\n amp_name, value = gain.split('=')\n gains[amp_name.strip()] = float(value.strip())\n return gains"
679 },
680 {
681 "code": "def _with_loc(f: W) -> W:\n @functools.wraps(f)\n def with_lineno_and_col(ctx):\n meta = lmap.map(\n {READER_LINE_KW: ctx.reader.line, READER_COL_KW: ctx.reader.col}\n )\n v = f(ctx)\n try:\n return v.with_meta(meta)\n except AttributeError:\n return v\n return cast(W, with_lineno_and_col)"
682 },
683 {
684 "code": "def updates(self, **kwargs):\n regs = regularizers.from_kwargs(self, **kwargs)\n _, updates = self.build_graph(regs)\n return updates"
685 },
686 {
687 "code": "def sqrt(wave):\n r\n dep_units = \"{0}**0.5\".format(wave.dep_units)\n return _operation(wave, \"sqrt\", dep_units, np.sqrt)"
688 },
689 {
690 "code": "def parse_args():\n usage = \"Usage: create_concordance <infile> [<outfile>]\"\n description = \"Simple Concordance Generator\"\n argparser = argparse.ArgumentParser(\n usage=usage, description=description)\n argparser.add_argument(\n 'infile', type=argparse.FileType('r'),\n help=\"File read in to create concordance\")\n argparser.add_argument(\n 'outfile', nargs='?', type=argparse.FileType('w'),\n default=sys.stdout, help=\"File to write concordance to. \"\n \"Default is stdout\")\n argparser.add_argument(\n '--word', nargs=\"?\", const=str, help=\"Display a word in concordance\")\n args = argparser.parse_args()\n return args"
691 },
692 {
693 "code": "def _count_table_rows(self, table_name):\n cursor = self._db.cursor()\n select_stmt = \"SELECT COUNT(*) FROM \" + table_name\n try:\n cursor.execute(select_stmt)\n row = cursor.fetchone()\n except sqlite3.DatabaseError as e:\n msg = \"invalid archive file; cause: %s\" % str(e)\n raise ArchiveError(cause=msg)\n finally:\n cursor.close()\n return row[0]"
694 },
695 {
696 "code": "def discount_status(request, form):\n discounts = form.cleaned_data[\"discount\"]\n items = commerce.DiscountItem.objects.filter(\n Q(discount__in=discounts),\n ).select_related(\"cart\", \"product\", \"product__category\")\n items = group_by_cart_status(\n items,\n [\"discount\"],\n [\"discount\", \"discount__description\"],\n )\n headings = [\n \"Discount\", \"Paid\", \"Reserved\", \"Unreserved\", \"Refunded\",\n ]\n data = []\n for item in items:\n data.append([\n item[\"discount__description\"],\n item[\"total_paid\"],\n item[\"total_reserved\"],\n item[\"total_unreserved\"],\n item[\"total_refunded\"],\n ])\n return ListReport(\"Usage by item\", headings, data)"
697 },
698 {
699 "code": "def spin(self):\n if self._notification_socket:\n self._flush_notifications()\n if self._iopub_socket:\n self._flush_iopub(self._iopub_socket)\n if self._mux_socket:\n self._flush_results(self._mux_socket)\n if self._task_socket:\n self._flush_results(self._task_socket)\n if self._control_socket:\n self._flush_control(self._control_socket)\n if self._query_socket:\n self._flush_ignored_hub_replies()"
700 },
701 {
702 "code": "def show(self, title=''):\n self.render(title=title)\n if self.fig:\n plt.show(self.fig)"
703 },
704 {
705 "code": "def f_get_groups(self, copy=True):\n if copy:\n return self._groups.copy()\n else:\n return self._groups"
706 },
707 {
708 "code": "def create_domain(self, domain_name, username=None, alphabet=Domain.DEFAULT_ALPHABET,\n length=Domain.DEFAULT_KEY_LENGTH):\n try:\n return self._create_domain(domain_name, username, alphabet, length)\n except Exception as ex:\n _logger.warn(\"Inserting new domain failed: %s\", ex)\n raise DuplicateDomainException"
709 },
710 {
711 "code": "def get_help(self):\n if self.help:\n return self.help\n elif self.__doc__ and self.__doc__.strip():\n return self.__doc__.strip()\n else:\n return ''"
712 },
713 {
714 "code": "def _unique_constraint_name(table: str, field, keys):\n postfix = '_'.join(keys)\n return '{table}_{field}_unique_{postfix}'.format(\n table=table,\n field=field.column,\n postfix=postfix\n )"
715 },
716 {
717 "code": "def get_result(self, indices_or_msg_ids=None, block=None):\n block = self.block if block is None else block\n if indices_or_msg_ids is None:\n indices_or_msg_ids = -1\n if not isinstance(indices_or_msg_ids, (list,tuple)):\n indices_or_msg_ids = [indices_or_msg_ids]\n theids = []\n for id in indices_or_msg_ids:\n if isinstance(id, int):\n id = self.history[id]\n if not isinstance(id, basestring):\n raise TypeError(\"indices must be str or int, not %r\"%id)\n theids.append(id)\n local_ids = filter(lambda msg_id: msg_id in self.history or msg_id in self.results, theids)\n remote_ids = filter(lambda msg_id: msg_id not in local_ids, theids)\n if remote_ids:\n ar = AsyncHubResult(self, msg_ids=theids)\n else:\n ar = AsyncResult(self, msg_ids=theids)\n if block:\n ar.wait()\n return ar"
718 },
719 {
720 "code": "def load_python_global(module, name):\n if module == '__builtin__' and six.PY3:\n module = 'builtins'\n module = importlib.import_module(module)\n return getattr(module, name)"
721 },
722 {
723 "code": "def _req_rep_retry(self, request):\n retries_left = self.RETRIES\n while retries_left:\n self._logger.log(1, 'Sending REQ `%s`', request)\n self._send_request(request)\n socks = dict(self._poll.poll(self.TIMEOUT))\n if socks.get(self._socket) == zmq.POLLIN:\n response = self._receive_response()\n self._logger.log(1, 'Received REP `%s`', response)\n return response, self.RETRIES - retries_left\n else:\n self._logger.debug('No response from server (%d retries left)' %\n retries_left)\n self._close_socket(confused=True)\n retries_left -= 1\n if retries_left == 0:\n raise RuntimeError('Server seems to be offline!')\n time.sleep(self.SLEEP)\n self._start_socket()"
724 },
725 {
726 "code": "def _check_inputs(self):\n try:\n _ = self._inputs[0]\n except TypeError:\n raise RuntimeError(\n \"inputs should be iterable but found type='{0}', value=\"\n \"'{1}'\".format(type(self._inputs), str(self._inputs)))\n from melody.inputs import Input\n for check_input in self._inputs:\n if not isinstance(check_input, Input):\n raise RuntimeError(\n \"input should be a subclass of the Input class but \"\n \"found type='{0}', value='{1}'\".format(type(check_input),\n str(check_input)))"
727 },
728 {
729 "code": "def individuals(context, institute, causatives, case_id):\n LOG.info(\"Running scout view individuals\")\n adapter = context.obj['adapter']\n individuals = []\n if case_id:\n case = adapter.case(case_id=case_id)\n if case:\n cases = [case]\n else:\n LOG.info(\"Could not find case %s\", case_id)\n return\n else:\n cases = [case_obj for case_obj in\n adapter.cases(\n collaborator=institute,\n has_causatives=causatives)]\n if len(cases) == 0:\n LOG.info(\"Could not find cases that match criteria\")\n return\n individuals = (ind_obj for case_obj in cases for ind_obj in case_obj['individuals'])\n click.echo(\"\n for case in cases:\n for ind_obj in case['individuals']:\n ind_info = [\n case['_id'], ind_obj['individual_id'],\n ind_obj['display_name'], SEX_MAP[int(ind_obj['sex'])],\n PHENOTYPE_MAP[ind_obj['phenotype']], ind_obj['mother'],\n ind_obj['father']\n ]\n click.echo('\\t'.join(ind_info))"
730 },
731 {
732 "code": "def show(self, *args, **kwargs):\n from webbrowser import open as webopen\n return webopen(str(self), *args, **kwargs)"
733 },
734 {
735 "code": "def insert_child ( self, object, index, child ):\n if isinstance( child, Subgraph ):\n object.subgraphs.insert( index, child )\n elif isinstance( child, Cluster ):\n object.clusters.insert( index, child )\n elif isinstance( child, Node ):\n object.nodes.insert( index, child )\n elif isinstance( child, Edge ):\n object.edges.insert( index, child )\n else:\n pass"
736 },
737 {
738 "code": "def get_private_keys(\n self,\n index=0,\n count=1,\n security_level=AddressGenerator.DEFAULT_SECURITY_LEVEL,\n ):\n return commands.GetPrivateKeysCommand(self.adapter)(\n seed=self.seed,\n index=index,\n count=count,\n securityLevel=security_level,\n )"
739 },
740 {
741 "code": "async def limited(until):\n duration = int(round(until - time.time()))\n mins = duration / 60\n fmt = 'We have exhausted a ratelimit quota. Retrying in %.2f seconds (%.3f minutes).'\n log.warn(fmt, duration, mins)"
742 },
743 {
744 "code": "def get_last_activities(self, n):\n filenames = self.get_activity_list().iloc[-n:].filename.tolist()\n last_activities = [self.get_activity(f) for f in filenames]\n return last_activities"
745 },
746 {
747 "code": "def fetch(self, category=CATEGORY_QUESTION, offset=DEFAULT_OFFSET):\n if not offset:\n offset = DEFAULT_OFFSET\n kwargs = {\"offset\": offset}\n items = super().fetch(category, **kwargs)\n return items"
748 },
749 {
750 "code": "def get_public_tokens(self):\n r = self.remote_utils.get_url(self.url() + \"public_tokens/\")\n return r.json()"
751 },
752 {
753 "code": "def validate_token(self, token, expected_data=None):\n try:\n data = self.load_token(token)\n if expected_data:\n for k in expected_data:\n if expected_data[k] != data[\"data\"].get(k):\n return None\n return data\n except BadData:\n return None"
754 },
755 {
756 "code": "async def set_session_state(self, state):\n await self._can_run()\n state = state.encode(self.encoding) if isinstance(state, six.text_type) else state\n return await self._mgmt_request_response(\n REQUEST_RESPONSE_SET_SESSION_STATE_OPERATION,\n {'session-id': self.session_id, 'session-state': bytearray(state)},\n mgmt_handlers.default)"
757 },
758 {
759 "code": "def error(self, relative_to='AME2003'):\n df = self.df - Table(relative_to).df\n return Table(df=df)"
760 },
761 {
762 "code": "def update_event_hub(self, hub_name, hub=None):\n _validate_not_none('hub_name', hub_name)\n request = HTTPRequest()\n request.method = 'PUT'\n request.host = self._get_host()\n request.path = '/' + _str(hub_name) + '?api-version=2014-01'\n request.body = _get_request_body(_convert_event_hub_to_xml(hub))\n request.path, request.query = self._httpclient._update_request_uri_query(request)\n request.headers.append(('If-Match', '*'))\n request.headers = self._update_service_bus_header(request)\n response = self._perform_request(request)\n return _convert_response_to_event_hub(response)"
763 },
764 {
765 "code": "def _get_pipeline_processes(self):\n with open(self.log_file) as fh:\n for line in fh:\n if re.match(\".*Creating operator.*\", line):\n match = re.match(\".*Creating operator > (.*) --\", line)\n process = match.group(1)\n if any([process.startswith(x) for x in self._blacklist]):\n continue\n if process not in self.skip_processes:\n self.processes[match.group(1)] = {\n \"barrier\": \"W\",\n \"submitted\": set(),\n \"finished\": set(),\n \"failed\": set(),\n \"retry\": set(),\n \"cpus\": None,\n \"memory\": None\n }\n self.process_tags[process] = {}\n if re.match(\".*Launching `.*` \\[.*\\] \", line):\n tag_match = re.match(\".*Launching `.*` \\[(.*)\\] \", line)\n self.pipeline_tag = tag_match.group(1) if tag_match else \\\n \"?\"\n name_match = re.match(\".*Launching `(.*)` \\[.*\\] \", line)\n self.pipeline_name = name_match.group(1) if name_match \\\n else \"?\"\n self.content_lines = len(self.processes)"
766 },
767 {
768 "code": "def allow_request(self, request, view):\n if request.method != 'POST':\n return True\n return super(PostRequestThrottleMixin, self).allow_request(request, view)"
769 },
770 {
771 "code": "def mr_reader(job, input_stream, loads=core.loads):\n for line in input_stream:\n yield loads(line),"
772 },
773 {
774 "code": "def until_traits_are_present(self, element_with_traits):\n end_time = time.time() + self._timeout\n count = 1\n missing_traits_descriptions = None\n while True:\n missing_traits_descriptions = []\n try:\n missing_traits_descriptions = element_with_traits.evaluate_traits()\n if len(missing_traits_descriptions) == 0:\n return True\n else:\n logger.debug(\"\n missing_traits_descriptions)))\n except self._ignored_exceptions as ex:\n logger.debug(\"Captured {0}: {1}\".format(str(ex.__class__).replace(\"<type '\", \"\").replace(\"'>\", \"\"),\n str(ex)))\n pass\n time.sleep(self._poll)\n count += 1\n if time.time() > end_time:\n break\n raise TimeoutException(\n msg=\"conditions \" + '<' + '> <'.join(missing_traits_descriptions) + '>' + \" not true after \" + str(\n self._timeout) + \" seconds.\")"
775 },
776 {
777 "code": "def find_max_rad_npnp(self):\n max_rad = 0\n max_npnp = 0\n for res, _ in self.items():\n if res != 'KEY':\n for _, ff_params in self[res].items():\n if max_rad < ff_params[1]:\n max_rad = ff_params[1]\n if max_npnp < ff_params[4]:\n max_npnp = ff_params[4]\n return max_rad, max_npnp"
778 },
779 {
780 "code": "def crscode_to_string(codetype, code, format):\n link = 'http://spatialreference.org/ref/%s/%s/%s/' %(codetype,code,format)\n result = urllib2.urlopen(link).read()\n if not isinstance(result, str):\n result = result.decode()\n return result"
781 },
782 {
783 "code": "def intern(self, sym: sym.Symbol, var: Var, force: bool = False) -> Var:\n m: lmap.Map = self._interns.swap(Namespace._intern, sym, var, force=force)\n return m.entry(sym)"
784 },
785 {
786 "code": "def clone(url, path):\n adapter = None\n if url[:4] == \"git@\" or url[-4:] == \".git\":\n adapter = Git(path)\n if url[:6] == \"svn://\":\n adapter = Svn(path)\n if url[:6] == \"bzr://\":\n adapter = Bzr(path)\n if url[:9] == \"ssh://hg@\":\n adapter = Hg(path)\n if adapter is None:\n raise RepositoryAdapterNotFound(\n \"Can't find adapter for `%s` repository url\" % url)\n return adapter.clone(url)"
787 },
788 {
789 "code": "def _send_file(self, local, remote):\n remote = \"%s:%s\" % (self.location, remote)\n for i in range(10):\n if not os.path.exists(local):\n self.log.debug(\"waiting for %s\" % local)\n time.sleep(1)\n else:\n break\n self.log.info(\"sending %s to %s\", local, remote)\n check_output(self.scp_cmd + [local, remote])"
790 },
791 {
792 "code": "def set_default_tlw(self, tlw, designer, inspector):\n \"track default top level window for toolbox menu default action\"\n self.designer = designer\n self.inspector = inspector"
793 },
794 {
795 "code": "def _chunk_pars(freq_vector, data_matrix, pformat):\n pformat = pformat.upper()\n length = 4\n for freq, data in zip(freq_vector, data_matrix):\n data = data.flatten()\n for index in range(0, data.size, length):\n fpoint = [freq] if not index else [None]\n cdata = data[index : index + length]\n if pformat == \"MA\":\n vector1 = np.abs(cdata)\n vector2 = np.rad2deg(np.angle(cdata))\n elif pformat == \"RI\":\n vector1 = np.real(cdata)\n vector2 = np.imag(cdata)\n else:\n vector1 = 20.0 * np.log10(np.abs(cdata))\n vector2 = np.rad2deg(np.angle(cdata))\n sep_data = np.array([])\n for item1, item2 in zip(vector1, vector2):\n sep_data = np.concatenate((sep_data, np.array([item1, item2])))\n ret = np.concatenate((np.array(fpoint), sep_data))\n yield ret"
796 },
797 {
798 "code": "def _determine_function_name_type(node, config=None):\n property_classes, property_names = _get_properties(config)\n if not node.is_method():\n return \"function\"\n if node.decorators:\n decorators = node.decorators.nodes\n else:\n decorators = []\n for decorator in decorators:\n if isinstance(decorator, astroid.Name) or (\n isinstance(decorator, astroid.Attribute)\n and decorator.attrname in property_names\n ):\n infered = utils.safe_infer(decorator)\n if infered and infered.qname() in property_classes:\n return \"attr\"\n elif isinstance(decorator, astroid.Attribute) and decorator.attrname in (\n \"setter\",\n \"deleter\",\n ):\n return \"attr\"\n return \"method\""
799 },
800 {
801 "code": "def get(self, name, factory, *factory_args, **factory_kwargs):\n update_thread_local = getattr(factory, 'update_thread_local', True)\n if (not update_thread_local) or (name not in self.__dict__):\n obj = factory(*factory_args, **factory_kwargs)\n if update_thread_local:\n setattr(self, name, obj)\n return obj\n return getattr(self, name)"
802 },
803 {
804 "code": "def _build_point_formats_dtypes(point_format_dimensions, dimensions_dict):\n return {\n fmt_id: _point_format_to_dtype(point_fmt, dimensions_dict)\n for fmt_id, point_fmt in point_format_dimensions.items()\n }"
805 },
806 {
807 "code": "def fetch_metric(self, metric, start, end, tags={}, aggregator=\"sum\",\n downsample=None, ms_resolution=True):\n query = \"{aggregator}:{downsample}{metric}{{{tags}}}\".format(\n aggregator=aggregator,\n downsample=downsample + \"-avg:\" if downsample else \"\",\n metric=metric,\n tags=','.join(\"%s=%s\" % (k, v) for k, v in tags.items())\n )\n params = {\n 'ms': ms_resolution,\n 'start': '{0:.3f}'.format(start.timestamp()),\n 'end': '{0:.3f}'.format(end.timestamp()),\n 'm': query\n }\n response = self.__request(\"/query\", params)\n if response.status_code == 200:\n try:\n return response.json()[0]['dps']\n except IndexError:\n return {}\n raise QueryError(response.json())"
808 },
809 {
810 "code": "def read(self):\n self.__fileobj.seek(self.data_offset)\n self.data = self.__fileobj.read(self.data_size)"
811 },
812 {
813 "code": "def gen_timeout_resend(attempts):\n timeout = 2 ** (attempts + 1) + random.uniform(-1, +1)\n logger.debug('next timeout resending will happen on %s',\n future_dt_str(nowutc(), timeout))\n return timeout"
814 },
815 {
816 "code": "def apply(self, method, args):\n try:\n params = args['params']\n if isinstance(params, dict):\n result = method(**params)\n else:\n result = method(*params)\n except Exception as error:\n server_error(args['id'], error)\n else:\n return result"
817 },
818 {
819 "code": "def _add_group_from_storage(self, args, kwargs):\n return self._nn_interface._add_generic(self,\n type_name=GROUP,\n group_type_name=GROUP,\n args=args,\n kwargs=kwargs,\n add_prefix=False,\n check_naming=False)"
820 },
821 {
822 "code": "def hflip(img):\n if not _is_pil_image(img):\n raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n return img.transpose(Image.FLIP_LEFT_RIGHT)"
823 },
824 {
825 "code": "def save_image(self, imagefile, save_path, file_ext, mime_type):\n file_to_save = InMemoryUploadedFile(\n imagefile,\n None,\n 'foo.%s' % file_ext,\n mime_type,\n imagefile.tell(),\n None\n )\n file_to_save.seek(0)\n self.storage.save(save_path, file_to_save)"
826 },
827 {
828 "code": "def draw(self):\n if not self.visible:\n return\n if not isinstance(self.submenu,Container):\n glEnable(GL_SCISSOR_TEST)\n glScissor(*self.pos+self.size)\n SubMenu.draw(self)\n if not isinstance(self.submenu,Container):\n glDisable(GL_SCISSOR_TEST)"
829 },
830 {
831 "code": "def cb_help_message(self, option, optname, value, parser):\n self.linter.msgs_store.help_message(utils._splitstrip(value))\n sys.exit(0)"
832 },
833 {
834 "code": "def open(path, mode=gdalconst.GA_ReadOnly):\n path = getattr(path, 'name', path)\n try:\n return Raster(vsiprefix(path), mode)\n except AttributeError:\n try:\n imgdata = path.read()\n except AttributeError:\n raise TypeError('Not a file-like object providing read()')\n else:\n imgio = MemFileIO(delete=False)\n gdal.FileFromMemBuffer(imgio.name, imgdata)\n return Raster(imgio, mode)\n raise ValueError('Failed to open raster from \"%r\"' % path)"
835 },
836 {
837 "code": "def from_connection_string(cls, conn_str, *, loop=None, **kwargs):\n address, policy, key, _ = parse_conn_str(conn_str)\n parsed_namespace = urlparse(address)\n namespace, _, base = parsed_namespace.hostname.partition('.')\n return cls(\n service_namespace=namespace,\n shared_access_key_name=policy,\n shared_access_key_value=key,\n host_base='.' + base,\n loop=loop,\n **kwargs)"
838 },
839 {
840 "code": "def _read_config(self):\n self._config_loaded = True\n conf = []\n for f in self._candidate_log_files():\n if os.path.isfile(f):\n self._logger.info(\"Reading config file %s\" % f)\n section_rx = re.compile(r\"^\\[(\\w+)\\]$\")\n keyvalue_rx = re.compile(r\"^(\\w+:)?([\\w.]+)\\s*=(.*)$\")\n with io.open(f, \"rt\", encoding=\"utf-8\") as config_file:\n section_name = None\n for lineno, line in enumerate(config_file):\n line = line.strip()\n if line == \"\" or line.startswith(\"\n m1 = section_rx.match(line)\n if m1:\n section_name = m1.group(1)\n continue\n m2 = keyvalue_rx.match(line)\n if m2:\n lng = m2.group(1)\n key = m2.group(2)\n val = m2.group(3).strip()\n if lng and lng.lower() != \"py:\": continue\n if section_name:\n key = section_name + \".\" + key\n if key in H2OConfigReader._allowed_config_keys:\n conf.append((key, val))\n else:\n self._logger.error(\"Key %s is not a valid config key\" % key)\n continue\n self._logger.error(\"Syntax error in config file line %d: %s\" % (lineno, line))\n self._config = dict(conf)\n return"
841 },
842 {
843 "code": "def clean_time_slots(self):\n ts = ((a[0], a[1]) for t in self.tiers.values() for a in t[0].values())\n for a in {a for b in ts for a in b} ^ set(self.timeslots):\n del(self.timeslots[a])"
844 },
845 {
846 "code": "def __last_beat(cumscore):\n maxes = util.localmax(cumscore)\n med_score = np.median(cumscore[np.argwhere(maxes)])\n return np.argwhere((cumscore * maxes * 2 > med_score)).max()"
847 },
848 {
849 "code": "def _basename_in_blacklist_re(base_name, black_list_re):\n for file_pattern in black_list_re:\n if file_pattern.match(base_name):\n return True\n return False"
850 },
851 {
852 "code": "def _parse_header(line):\n parts = _parseparam(';' + line)\n key = parts.next()\n pdict = {}\n for p in parts:\n i = p.find('=')\n if i >= 0:\n name = p[:i].strip().lower()\n value = p[i+1:].strip()\n if len(value) >= 2 and value[0] == value[-1] == '\"':\n value = value[1:-1]\n value = value.replace('\\\\\\\\', '\\\\').replace('\\\\\"', '\"')\n pdict[name] = value\n return key, pdict"
853 },
854 {
855 "code": "def plot_tree(T, res=None, title=None, cmap_id=\"Pastel2\"):\n import matplotlib.pyplot as plt\n def round_time(t, res=0.1):\n v = int(t / float(res)) * res\n return v\n cmap = plt.get_cmap(cmap_id)\n level_bounds = []\n for level in T.levels:\n if level == \"root\":\n continue\n segments = T.get_segments_in_level(level)\n level_bounds.append(segments)\n B = float(len(level_bounds))\n for i, segments in enumerate(level_bounds):\n labels = utils.segment_labels_to_floats(segments)\n for segment, label in zip(segments, labels):\n if res is None:\n start = segment.start\n end = segment.end\n xlabel = \"Time (seconds)\"\n else:\n start = int(round_time(segment.start, res=res) / res)\n end = int(round_time(segment.end, res=res) / res)\n xlabel = \"Time (frames)\"\n plt.axvspan(start, end,\n ymax=(len(level_bounds) - i) / B,\n ymin=(len(level_bounds) - i - 1) / B,\n facecolor=cmap(label))\n L = float(len(T.levels) - 1)\n plt.yticks(np.linspace(0, (L - 1) / L, num=L) + 1 / L / 2.,\n T.levels[1:][::-1])\n plt.xlabel(xlabel)\n if title is not None:\n plt.title(title)\n plt.gca().set_xlim([0, end])"
856 },
857 {
858 "code": "def validate_zone(zone):\n if not has_valid_id(zone):\n raise InvalidZone(\"%s must contain a valid 'id' attribute\" % zone.__name__)\n if not has_valid_name(zone):\n raise InvalidZone(\"%s must contain a valid 'name' attribute\" % zone.__name__)"
859 },
860 {
861 "code": "def _merge(self, old, new, use_equals=False):\n if old is None:\n return new\n if new is None:\n return old\n if (old == new) if use_equals else (old is new):\n return old\n raise ValueError(\"Incompatible values: %s != %s\" % (old, new))"
862 },
863 {
864 "code": "def list(self, resource=None, type=None, actorId=None, _from=None, to=None,\n max=None, **request_parameters):\n check_type(resource, basestring)\n check_type(type, basestring)\n check_type(actorId, basestring)\n check_type(_from, basestring)\n check_type(to, basestring)\n check_type(max, int)\n params = dict_from_items_with_values(\n request_parameters,\n resource=resource,\n type=type,\n actorId=actorId,\n _from=_from,\n to=to,\n max=max,\n )\n if _from:\n params[\"from\"] = params.pop(\"_from\")\n items = self._session.get_items(API_ENDPOINT, params=params)\n for item in items:\n yield self._object_factory(OBJECT_TYPE, item)"
865 },
866 {
867 "code": "def _reformat_historical_formating_error(self):\n if PyFunceble.CONFIGURATION[\"inactive_database\"]:\n historical_formating_error = (\n PyFunceble.CURRENT_DIRECTORY + \"inactive-db.json\"\n )\n if PyFunceble.path.isfile(historical_formating_error):\n data = Dict().from_json(File(historical_formating_error).read())\n data_to_parse = {}\n top_keys = data.keys()\n for top_key in top_keys:\n low_keys = data[top_key].keys()\n data_to_parse[top_key] = {}\n for low_key in low_keys:\n if low_key.isdigit():\n data_to_parse[top_key][\n int(low_key) - (self.one_day_in_seconds * 30)\n ] = data[top_key][low_key]\n else:\n data_to_parse[top_key][\n int(PyFunceble.time()) - (self.one_day_in_seconds * 30)\n ] = data[top_key][low_key]\n if \"inactive_db\" in PyFunceble.INTERN:\n PyFunceble.INTERN[\"inactive_db\"].update(data_to_parse)\n else:\n PyFunceble.INTERN[\"inactive_db\"] = data_to_parse\n File(historical_formating_error).delete()"
868 },
869 {
870 "code": "def _copy_image(self, name):\n image = self._get_image(name)\n QtGui.QApplication.clipboard().setImage(image)"
871 },
872 {
873 "code": "def list(self):\n url = \"api/v0002/mgmt/custom/bundle\"\n r = self._apiClient.get(url)\n if r.status_code == 200:\n return r.json()\n else:\n raise ApiException(r)"
874 },
875 {
876 "code": "def log_attempt(self, key):\n with self.lock:\n if key not in self.attempts:\n self.attempts[key] = 1\n else:\n self.attempts[key] += 1\n if self.attempts[key] >= self.max_attempts:\n log.info('Account %s locked due to too many login attempts' % key)\n self.locks[key] = datetime.datetime.utcnow() + datetime.timedelta(seconds=self.lock_duration)"
877 },
878 {
879 "code": "def get_process_gids(self):\n real, effective, saved = _psutil_bsd.get_process_gids(self.pid)\n return nt_gids(real, effective, saved)"
880 },
881 {
882 "code": "def get_service_certificate(self, service_name, thumbalgorithm, thumbprint):\n _validate_not_none('service_name', service_name)\n _validate_not_none('thumbalgorithm', thumbalgorithm)\n _validate_not_none('thumbprint', thumbprint)\n return self._perform_get(\n '/' + self.subscription_id + '/services/hostedservices/' +\n _str(service_name) + '/certificates/' +\n _str(thumbalgorithm) + '-' + _str(thumbprint) + '',\n Certificate)"
883 },
884 {
885 "code": "def calc_n_ints_in_file(filename):\n h = read_header(filename)\n n_bytes = int(h[b'nbits'] / 8)\n n_chans = h[b'nchans']\n n_ifs = h[b'nifs']\n idx_data = len_header(filename)\n f = open(filename, 'rb')\n f.seek(idx_data)\n filesize = os.path.getsize(filename)\n n_bytes_data = filesize - idx_data\n if h[b'nbits'] == 2:\n n_ints = int(4 * n_bytes_data / (n_chans * n_ifs))\n else:\n n_ints = int(n_bytes_data / (n_bytes * n_chans * n_ifs))\n return n_ints"
886 },
887 {
888 "code": "def collect_things_entry_points():\n things = dict()\n for entry_point in iter_entry_points(group='invenio_migrator.things'):\n things[entry_point.name] = entry_point.load()\n return things"
889 },
890 {
891 "code": "def _check_token_present(self):\n\t\ttry:\n\t\t\tself._get_value(CONFIGKEY_TOKEN)\n\t\t\tself._get_value(CONFIGKEY_REFRESH_TOKEN)\n\t\t\tself._get_value(CONFIGKEY_REFRESHABLE)\n\t\texcept KeyError:\n\t\t\tself._log(\"Request new Token (CTP)\")\n\t\t\tself._get_new_access_information()"
892 },
893 {
894 "code": "def parse(self, *args):\n parsed_args = self.parser.parse_args(args)\n if parsed_args.category is None:\n delattr(parsed_args, 'category')\n if self._from_date:\n parsed_args.from_date = str_to_datetime(parsed_args.from_date)\n if self._to_date and parsed_args.to_date:\n parsed_args.to_date = str_to_datetime(parsed_args.to_date)\n if self._archive and parsed_args.archived_since:\n parsed_args.archived_since = str_to_datetime(parsed_args.archived_since)\n if self._archive and parsed_args.fetch_archive and parsed_args.no_archive:\n raise AttributeError(\"fetch-archive and no-archive arguments are not compatible\")\n if self._archive and parsed_args.fetch_archive and not parsed_args.category:\n raise AttributeError(\"fetch-archive needs a category to work with\")\n for alias, arg in self.aliases.items():\n if (alias not in parsed_args) and (arg in parsed_args):\n value = getattr(parsed_args, arg, None)\n setattr(parsed_args, alias, value)\n return parsed_args"
895 },
896 {
897 "code": "def connection_lost(self, exc):\n logger.debug(\"worker connection lost\")\n self._worker.close()\n self._workers.remove(self._worker)"
898 },
899 {
900 "code": "def register_handler(self, name, handler, esc_strings):\n self._handlers[name] = handler\n for esc_str in esc_strings:\n self._esc_handlers[esc_str] = handler"
901 },
902 {
903 "code": "def get_plugin_option(self, plugin, key):\n if plugin in self.plugins:\n plugin = self.plugins[plugin]\n return plugin.get_option(key)"
904 },
905 {
906 "code": "def release(self):\n if self.table is None:\n raise GiraffeError(\"Cannot release. Target table has not been set.\")\n log.info(\"BulkLoad\", \"Attempting release for table {}\".format(self.table))\n self.mload.release(self.table)"
907 },
908 {
909 "code": "def get_enumerations_from_bit_mask(enumeration, mask):\n return [x for x in enumeration if (x.value & mask) == x.value]"
910 },
911 {
912 "code": "def update_w(self):\n def update_single_w(i):\n FB = base.matrix(np.float64(np.dot(-self.data.T, W_hat[:,i])))\n be = solvers.qp(HB, FB, INQa, INQb, EQa, EQb)\n self.beta[i,:] = np.array(be['x']).reshape((1, self._num_samples))\n HB = base.matrix(np.float64(np.dot(self.data[:,:].T, self.data[:,:])))\n EQb = base.matrix(1.0, (1, 1))\n W_hat = np.dot(self.data, pinv(self.H))\n INQa = base.matrix(-np.eye(self._num_samples))\n INQb = base.matrix(0.0, (self._num_samples, 1))\n EQa = base.matrix(1.0, (1, self._num_samples))\n for i in range(self._num_bases):\n update_single_w(i)\n self.W = np.dot(self.beta, self.data.T).T"
913 },
914 {
915 "code": "def inverse(self):\n return Snapshot(self.num_qubits, self.num_clbits, self.params[0],\n self.params[1])"
916 },
917 {
918 "code": "def prune_all(self) -> int:\n from .repositories import PriceRepository\n repo = PriceRepository()\n items = repo.query.distinct(dal.Price.namespace, dal.Price.symbol).all()\n count = 0\n for item in items:\n symbol = SecuritySymbol(item.namespace, item.symbol)\n deleted = self.prune(symbol)\n if deleted:\n count += 1\n return count"
919 },
920 {
921 "code": "def _merge_single_runs(self, other_trajectory, used_runs):\n count = len(self)\n run_indices = range(len(other_trajectory))\n run_name_dict = OrderedDict()\n to_store_groups_with_annotations = []\n for idx in run_indices:\n if idx in used_runs:\n other_info_dict = other_trajectory.f_get_run_information(idx)\n time_ = other_info_dict['time']\n timestamp = other_info_dict['timestamp']\n completed = other_info_dict['completed']\n short_environment_hexsha = other_info_dict['short_environment_hexsha']\n finish_timestamp = other_info_dict['finish_timestamp']\n runtime = other_info_dict['runtime']\n new_idx = used_runs[idx]\n new_runname = self.f_wildcard('$', new_idx)\n run_name_dict[idx] = new_runname\n info_dict = dict(\n idx=new_idx,\n time=time_,\n timestamp=timestamp,\n completed=completed,\n short_environment_hexsha=short_environment_hexsha,\n finish_timestamp=finish_timestamp,\n runtime=runtime)\n self._add_run_info(**info_dict)"
922 },
923 {
924 "code": "def _get_resource_url(self, url, auto_page, data_key):\n headers = {'Accept': 'application/json',\n 'Connection': 'keep-alive'}\n response = DAO.getURL(url, headers)\n if response.status != 200:\n raise DataFailureException(url, response.status, response.data)\n data = json.loads(response.data)\n self.next_page_url = self._next_page(response)\n if auto_page and self.next_page_url:\n if isinstance(data, list):\n data.extend(self._get_resource_url(self.next_page_url, True,\n data_key))\n elif isinstance(data, dict) and data_key is not None:\n data[data_key].extend(self._get_resource_url(\n self.next_page_url, True, data_key)[data_key])\n return data"
925 },
926 {
927 "code": "def start_workers(self, workers_per_task=1):\n if not self.workers:\n for _ in range(workers_per_task):\n self.workers.append(Worker(self._download, self.queues['download'], self.queues['convert'], self.stopper))\n self.workers.append(Worker(self._convert, self.queues['convert'], self.queues['upload'], self.stopper))\n self.workers.append(Worker(self._upload, self.queues['upload'], self.queues['delete'], self.stopper))\n self.workers.append(Worker(self._delete, self.queues['delete'], self.queues['done'], self.stopper))\n self.signal_handler = SignalHandler(self.workers, self.stopper)\n signal.signal(signal.SIGINT, self.signal_handler)\n for worker in self.workers:\n worker.start()"
928 },
929 {
930 "code": "def bind_parameters(self, value_dict):\n new_circuit = self.copy()\n if value_dict.keys() > self.parameters:\n raise QiskitError('Cannot bind parameters ({}) not present in the circuit.'.format(\n [str(p) for p in value_dict.keys() - self.parameters]))\n for parameter, value in value_dict.items():\n new_circuit._bind_parameter(parameter, value)\n for parameter in value_dict:\n del new_circuit._parameter_table[parameter]\n return new_circuit"
931 },
932 {
933 "code": "def _delete_resource(self, url):\n params = {}\n self._set_as_user(params)\n headers = {'Accept': 'application/json',\n 'Connection': 'keep-alive'}\n url = url + self._params(params)\n response = DAO.deleteURL(url, headers)\n if not (response.status == 200 or response.status == 204):\n raise DataFailureException(url, response.status, response.data)\n return response"
934 },
935 {
936 "code": "def process_module(self, node):\n if self.config.file_header:\n if sys.version_info[0] < 3:\n pattern = re.compile(\n '\\A' + self.config.file_header, re.LOCALE | re.MULTILINE)\n else:\n pattern = re.compile(\n '\\A' + self.config.file_header, re.MULTILINE)\n content = None\n with node.stream() as stream:\n content = stream.read().decode('utf-8')\n matches = pattern.findall(content)\n if len(matches) != 1:\n self.add_message('invalid-file-header', 1,\n args=self.config.file_header)"
937 },
938 {
939 "code": "def tree_climber(self, tree_alias, base_item):\n if base_item is not None:\n base_item.in_current_branch = True\n if hasattr(base_item, 'parent') and base_item.parent is not None:\n self.tree_climber(tree_alias, self.get_item_by_id(tree_alias, base_item.parent.id))"
940 },
941 {
942 "code": "def convert_acquire(self, shift, instruction):\n meas_level = self._run_config.get('meas_level', 2)\n command_dict = {\n 'name': 'acquire',\n 't0': shift+instruction.start_time,\n 'duration': instruction.duration,\n 'qubits': [q.index for q in instruction.acquires],\n 'memory_slot': [m.index for m in instruction.mem_slots]\n }\n if meas_level == 2:\n if instruction.command.discriminator:\n command_dict.update({\n 'discriminators': [\n QobjMeasurementOption(\n name=instruction.command.discriminator.name,\n params=instruction.command.discriminator.params)\n ]\n })\n command_dict.update({\n 'register_slot': [regs.index for regs in instruction.reg_slots]\n })\n if meas_level >= 1:\n if instruction.command.kernel:\n command_dict.update({\n 'kernels': [\n QobjMeasurementOption(\n name=instruction.command.kernel.name,\n params=instruction.command.kernel.params)\n ]\n })\n return self._qobj_model(**command_dict)"
943 },
944 {
945 "code": "def getUserId(self):\n self.userId = self(\"GET\", \"{0}/users/self/profile\".format(self.API_USER),\n auth=self.Auth.SkypeToken).json().get(\"username\")"
946 },
947 {
948 "code": "def fields(self, *fields):\n if len(fields) == 0:\n return [el.split() for el in self]\n res = SList()\n for el in [f.split() for f in self]:\n lineparts = []\n for fd in fields:\n try:\n lineparts.append(el[fd])\n except IndexError:\n pass\n if lineparts:\n res.append(\" \".join(lineparts))\n return res"
949 },
950 {
951 "code": "def run_picard_sort(job, bam, sort_by_name=False):\n work_dir = job.fileStore.getLocalTempDir()\n job.fileStore.readGlobalFile(bam, os.path.join(work_dir, 'input.bam'))\n command = ['SortSam',\n 'O=/data/output.bam',\n 'I=/data/input.bam']\n docker_parameters = ['--rm',\n '--log-driver', 'none',\n '-e', 'JAVA_OPTIONS=-Djava.io.tmpdir=/data/ -Xmx{}'.format(job.memory),\n '-v', '{}:/data'.format(work_dir)]\n if sort_by_name:\n command.append('SO=queryname')\n else:\n command.append('SO=coordinate')\n start_time = time.time()\n dockerCall(job=job, workDir=work_dir,\n parameters=command,\n tool='quay.io/ucsc_cgl/picardtools:1.95--dd5ac549b95eb3e5d166a5e310417ef13651994e',\n dockerParameters=docker_parameters)\n end_time = time.time()\n _log_runtime(job, start_time, end_time, \"Picard SortSam\")\n return job.fileStore.writeGlobalFile(os.path.join(work_dir, 'output.bam'))"
952 },
953 {
954 "code": "def crash_handler_lite(etype, evalue, tb):\n traceback.print_exception(etype, evalue, tb)\n from IPython.core.interactiveshell import InteractiveShell\n if InteractiveShell.initialized():\n config = \"%config \"\n else:\n config = \"c.\"\n print >> sys.stderr, _lite_message_template.format(email=author_email, config=config)"
955 },
956 {
957 "code": "def rule(cls, rulename=None, erase=False):\n if not hasattr(cls, '_rules'):\n raise TypeError(\n \"%s didn't seems to be a BasicParser subsclasse\" % cls.__name__)\n class_hook_list = cls._hooks\n class_rule_list = cls._rules\n def wrapper(f):\n nonlocal rulename\n add_method(cls)(f)\n if rulename is None:\n rulename = f.__name__\n if not erase and (rulename in class_hook_list or rulename in class_rule_list):\n raise TypeError(\"%s is already define has rule or hook\" % rulename)\n if '.' not in rulename:\n rulename = cls.__module__ + '.' + cls.__name__ + '.' + rulename\n set_one(class_rule_list, rulename, f)\n return f\n return wrapper"
958 },
959 {
960 "code": "def set_request_header(self, name, value):\n _name = BSTR(name)\n _value = BSTR(value)\n _WinHttpRequest._SetRequestHeader(self, _name, _value)"
961 },
962 {
963 "code": "def source_expand(self, source):\n result = []\n if not isinstance(source, list):\n source = [source]\n for src in source:\n tmp = self.opt.recursive\n self.opt.recursive = False\n result += [f['name'] for f in self.s3walk(src, True)]\n self.opt.recursive = tmp\n if (len(result) == 0) and (not self.opt.ignore_empty_source):\n fail(\"[Runtime Failure] Source doesn't exist.\")\n return result"
964 },
965 {
966 "code": "def new_frontend_master(self):\n ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST\n kernel_manager = self.kernel_manager_class(\n ip=ip,\n connection_file=self._new_connection_file(),\n config=self.config,\n )\n kwargs = dict()\n kwargs['extra_arguments'] = self.kernel_argv\n kernel_manager.start_kernel(**kwargs)\n kernel_manager.start_channels()\n widget = self.widget_factory(config=self.config,\n local_kernel=True)\n self.init_colors(widget)\n widget.kernel_manager = kernel_manager\n widget._existing = False\n widget._may_close = True\n widget._confirm_exit = self.confirm_exit\n return widget"
967 },
968 {
969 "code": "def valid(self):\n if self.expiration_time:\n return self.expiration_time > int(time.time())\n else:\n return True"
970 },
971 {
972 "code": "def add_new_heart_handler(self, handler):\n self.log.debug(\"heartbeat::new_heart_handler: %s\", handler)\n self._new_handlers.add(handler)"
973 },
974 {
975 "code": "def get_ordered_list_type(meta_data, numId, ilvl):\n numbering_dict = meta_data.numbering_dict\n if numId not in numbering_dict:\n return DEFAULT_LIST_NUMBERING_STYLE\n if ilvl not in numbering_dict[numId]:\n return DEFAULT_LIST_NUMBERING_STYLE\n return meta_data.numbering_dict[numId][ilvl]"
976 },
977 {
978 "code": "def configure_inline_support(shell, backend, user_ns=None):\n try:\n from IPython.zmq.pylab.backend_inline import InlineBackend\n except ImportError:\n return\n user_ns = shell.user_ns if user_ns is None else user_ns\n cfg = InlineBackend.instance(config=shell.config)\n cfg.shell = shell\n if cfg not in shell.configurables:\n shell.configurables.append(cfg)\n if backend == backends['inline']:\n from IPython.zmq.pylab.backend_inline import flush_figures\n from matplotlib import pyplot\n shell.register_post_execute(flush_figures)\n pyplot.rcParams.update(cfg.rc)\n user_ns['figsize'] = pyplot.figsize = figsize\n fmt = cfg.figure_format\n select_figure_format(shell, fmt)\n from IPython.core.display import display\n user_ns['display'] = display\n user_ns['getfigs'] = getfigs"
979 },
980 {
981 "code": "def decode_bytecode(bytecode):\n bytecode_wnd = memoryview(bytecode)\n while bytecode_wnd:\n opcode_id = byte2int(bytecode_wnd[0])\n opcode = OPCODE_MAP[opcode_id]\n if opcode.imm_struct is not None:\n offs, imm, _ = opcode.imm_struct.from_raw(None, bytecode_wnd[1:])\n else:\n imm = None\n offs = 0\n insn_len = 1 + offs\n yield Instruction(opcode, imm, insn_len)\n bytecode_wnd = bytecode_wnd[insn_len:]"
982 },
983 {
984 "code": "def __complete_interns(\n self, value: str, include_private_vars: bool = True\n ) -> Iterable[str]:\n if include_private_vars:\n is_match = Namespace.__completion_matcher(value)\n else:\n _is_match = Namespace.__completion_matcher(value)\n def is_match(entry: Tuple[sym.Symbol, Var]) -> bool:\n return _is_match(entry) and not entry[1].is_private\n return map(\n lambda entry: f\"{entry[0].name}\",\n filter(is_match, [(s, v) for s, v in self.interns]),\n )"
985 },
986 {
987 "code": "def configure(self, options, config):\n Plugin.configure(self, options, config)\n self.config = config\n if self.enabled:\n self.stats = {'errors': 0,\n 'failures': 0,\n 'passes': 0,\n 'skipped': 0\n }\n self.errorlist = []\n self.error_report_file = codecs.open(options.xunit_file, 'w',\n self.encoding, 'replace')"
988 },
989 {
990 "code": "def renew_lock(self):\n if self._queue_name:\n self.service_bus_service.renew_lock_queue_message(\n self._queue_name,\n self.broker_properties['SequenceNumber'],\n self.broker_properties['LockToken'])\n elif self._topic_name and self._subscription_name:\n self.service_bus_service.renew_lock_subscription_message(\n self._topic_name,\n self._subscription_name,\n self.broker_properties['SequenceNumber'],\n self.broker_properties['LockToken'])\n else:\n raise AzureServiceBusPeekLockError(_ERROR_MESSAGE_NOT_PEEK_LOCKED_ON_RENEW_LOCK)"
991 },
992 {
993 "code": "def call(self, inputs):\n net = self.encoder_net(tf.cast(inputs, tf.float32))\n return ed.MultivariateNormalDiag(\n loc=net[..., :self.latent_size],\n scale_diag=tf.nn.softplus(net[..., self.latent_size:]),\n name=\"latent_code_posterior\")"
994 },
995 {
996 "code": "def kvlayer_key_to_stream_id(k):\n abs_url_hash, epoch_ticks = k\n return '{0}-{1}'.format(epoch_ticks,\n base64.b16encode(abs_url_hash).lower())"
997 },
998 {
999 "code": "def update_binary_annotations(self, extra_annotations):\n if not self.logging_context:\n self.binary_annotations.update(extra_annotations)\n else:\n self.logging_context.tags.update(extra_annotations)"
1000 },
1001 {
1002 "code": "def status(self,verbose=0):\n self._update_status()\n self._group_report(self.running,'Running')\n self._group_report(self.completed,'Completed')\n self._group_report(self.dead,'Dead')\n self._comp_report[:] = []\n self._dead_report[:] = []"
1003 },
1004 {
1005 "code": "def visit_table(self, layout):\n table_content = self.get_table_content(layout)\n cols_width = [0] * len(table_content[0])\n for row in table_content:\n for index, col in enumerate(row):\n cols_width[index] = max(cols_width[index], len(col))\n self.default_table(layout, table_content, cols_width)\n self.writeln()"
1006 },
1007 {
1008 "code": "def no_exp(number):\n r\n mant, exp = to_scientific_tuple(number)\n if not exp:\n return str(number)\n floating_mant = \".\" in mant\n mant = mant.replace(\".\", \"\")\n if exp < 0:\n return \"0.\" + \"0\" * (-exp - 1) + mant\n if not floating_mant:\n return mant + \"0\" * exp + (\".0\" if isinstance(number, float) else \"\")\n lfpart = len(mant) - 1\n if lfpart < exp:\n return (mant + \"0\" * (exp - lfpart)).rstrip(\".\")\n return mant"
1009 },
1010 {
1011 "code": "def url_query_params(url):\n return dict(urlparse.parse_qsl(urlparse.urlparse(url).query, True))"
1012 },
1013 {
1014 "code": "def path_dispatch_old_new(mname, returns_model):\n def _wrapper(self, old_path, new_path, *args, **kwargs):\n old_prefix, old_mgr, old_mgr_path = _resolve_path(\n old_path, self.managers\n )\n new_prefix, new_mgr, new_mgr_path = _resolve_path(\n new_path, self.managers,\n )\n if old_mgr is not new_mgr:\n raise HTTPError(\n 400,\n \"Can't move files between backends ({old} -> {new})\".format(\n old=old_path,\n new=new_path,\n )\n )\n assert new_prefix == old_prefix\n result = getattr(new_mgr, mname)(\n old_mgr_path,\n new_mgr_path,\n *args,\n **kwargs\n )\n if returns_model and new_prefix:\n return _apply_prefix(new_prefix, result)\n else:\n return result\n return _wrapper"
1015 },
1016 {
1017 "code": "def get_admins(self, account_id, params={}):\n url = ADMINS_API.format(account_id)\n admins = []\n for data in self._get_paged_resource(url, params=params):\n admins.append(CanvasAdmin(data=data))\n return admins"
1018 },
1019 {
1020 "code": "def set_feature_transform(self, mode='polynomial', degree=1):\n if self.status != 'load_train_data':\n print(\"Please load train data first.\")\n return self.train_X\n self.feature_transform_mode = mode\n self.feature_transform_degree = degree\n self.train_X = self.train_X[:, 1:]\n self.train_X = utility.DatasetLoader.feature_transform(\n self.train_X,\n self.feature_transform_mode,\n self.feature_transform_degree\n )\n return self.train_X"
1021 },
1022 {
1023 "code": "def _wanmen_get_title_by_json_topic_part(json_content, tIndex, pIndex):\n return '_'.join([json_content[0]['name'],\n json_content[0]['Topics'][tIndex]['name'],\n json_content[0]['Topics'][tIndex]['Parts'][pIndex]['name']])"
1024 },
1025 {
1026 "code": "def fallback_to_default_project_id(func):\n @functools.wraps(func)\n def inner_wrapper(self, *args, **kwargs):\n if len(args) > 0:\n raise AirflowException(\n \"You must use keyword arguments in this methods rather than\"\n \" positional\")\n if 'project_id' in kwargs:\n kwargs['project_id'] = self._get_project_id(kwargs['project_id'])\n else:\n kwargs['project_id'] = self._get_project_id(None)\n if not kwargs['project_id']:\n raise AirflowException(\"The project id must be passed either as \"\n \"keyword project_id parameter or as project_id extra \"\n \"in GCP connection definition. Both are not set!\")\n return func(self, *args, **kwargs)\n return inner_wrapper"
1027 },
1028 {
1029 "code": "def get_model_class(settings_entry_name):\n app_name, model_name = get_app_n_model(settings_entry_name)\n try:\n model = apps_get_model(app_name, model_name)\n except (LookupError, ValueError):\n model = None\n if model is None:\n raise ImproperlyConfigured(\n '`SITETREE_%s` refers to model `%s` that has not been installed.' % (settings_entry_name, model_name))\n return model"
1030 },
1031 {
1032 "code": "def draw(self):\n self.screen.border(0)\n if self.title is not None:\n self.screen.addstr(2, 2, self.title, curses.A_STANDOUT)\n if self.subtitle is not None:\n self.screen.addstr(4, 2, self.subtitle, curses.A_BOLD)\n for index, item in enumerate(self.items):\n if self.current_option == index:\n text_style = self.highlight\n else:\n text_style = self.normal\n self.screen.addstr(5 + index, 4, item.show(index), text_style)\n screen_rows, screen_cols = CursesMenu.stdscr.getmaxyx()\n top_row = 0\n if 6 + len(self.items) > screen_rows:\n if screen_rows + self.current_option < 6 + len(self.items):\n top_row = self.current_option\n else:\n top_row = 6 + len(self.items) - screen_rows\n self.screen.refresh(top_row, 0, 0, 0, screen_rows - 1, screen_cols - 1)"
1033 },
1034 {
1035 "code": "def svg_to_image(string, size=None):\n if isinstance(string, unicode):\n string = string.encode('utf-8')\n renderer = QtSvg.QSvgRenderer(QtCore.QByteArray(string))\n if not renderer.isValid():\n raise ValueError('Invalid SVG data.')\n if size is None:\n size = renderer.defaultSize()\n image = QtGui.QImage(size, QtGui.QImage.Format_ARGB32)\n painter = QtGui.QPainter(image)\n renderer.render(painter)\n return image"
1036 },
1037 {
1038 "code": "def token_indent(self, idx):\n line_indent = self.line_indent(idx)\n return line_indent + \" \" * (self.start_col(idx) - len(line_indent))"
1039 },
1040 {
1041 "code": "def close(self):\n self.flush()\n setattr(sys, self.channel, self.ostream)\n self.file.close()\n self._closed = True"
1042 },
1043 {
1044 "code": "def info(self):\n for key, val in self.header.items():\n if key == b'src_raj':\n val = val.to_string(unit=u.hour, sep=':')\n if key == b'src_dej':\n val = val.to_string(unit=u.deg, sep=':')\n if key == b'tsamp':\n val *= u.second\n if key in ('foff', 'fch1'):\n val *= u.MHz\n if key == b'tstart':\n print(\"%16s : %32s\" % (\"tstart (ISOT)\", Time(val, format='mjd').isot))\n key = \"tstart (MJD)\"\n print(\"%16s : %32s\" % (key, val))\n print(\"\\n%16s : %32s\" % (\"Num ints in file\", self.n_ints_in_file))\n print(\"%16s : %32s\" % (\"Data shape\", self.data.shape))\n print(\"%16s : %32s\" % (\"Start freq (MHz)\", self.freqs[0]))\n print(\"%16s : %32s\" % (\"Stop freq (MHz)\", self.freqs[-1]))"
1045 },
1046 {
1047 "code": "def fromRaw(cls, skype=None, raw={}):\n return cls(skype, raw, **cls.rawToFields(raw))"
1048 },
1049 {
1050 "code": "def inherit_from_std_ex(node: astroid.node_classes.NodeNG) -> bool:\n ancestors = node.ancestors() if hasattr(node, \"ancestors\") else []\n for ancestor in itertools.chain([node], ancestors):\n if (\n ancestor.name in (\"Exception\", \"BaseException\")\n and ancestor.root().name == EXCEPTIONS_MODULE\n ):\n return True\n return False"
1051 },
1052 {
1053 "code": "def findStationCodesByCity(city_name, token):\n req = requests.get(\n API_ENDPOINT_SEARCH,\n params={\n 'token': token,\n 'keyword': city_name\n })\n if req.status_code == 200 and req.json()[\"status\"] == \"ok\":\n return [result[\"uid\"] for result in req.json()[\"data\"]]\n else:\n return []"
1054 },
1055 {
1056 "code": "def v2_playbook_on_task_start(self, task, **kwargs):\n self.last_task_name = task.get_name()\n self.printed_last_task = False"
1057 },
1058 {
1059 "code": "def _register_stements(self, statements: List[\"HdlStatement\"],\n target: List[\"HdlStatement\"]):\n for stm in flatten(statements):\n assert stm.parentStm is None, stm\n stm._set_parent_stm(self)\n target.append(stm)"
1060 },
1061 {
1062 "code": "def _query_cassandra(self):\n self.hook = CassandraHook(cassandra_conn_id=self.cassandra_conn_id)\n session = self.hook.get_conn()\n cursor = session.execute(self.cql)\n return cursor"
1063 },
1064 {
1065 "code": "def request_tokens(self):\n url = 'https://api.ecobee.com/token'\n params = {'grant_type': 'ecobeePin', 'code': self.authorization_code,\n 'client_id': self.api_key}\n try:\n request = requests.post(url, params=params)\n except RequestException:\n logger.warn(\"Error connecting to Ecobee. Possible connectivity outage.\"\n \"Could not request token.\")\n return\n if request.status_code == requests.codes.ok:\n self.access_token = request.json()['access_token']\n self.refresh_token = request.json()['refresh_token']\n self.write_tokens_to_file()\n self.pin = None\n else:\n logger.warn('Error while requesting tokens from ecobee.com.'\n ' Status code: ' + str(request.status_code))\n return"
1066 },
1067 {
1068 "code": "def cancel_task(self, task_id):\n self.registry.remove(task_id)\n self._scheduler.cancel_job_task(task_id)\n logger.info(\"Task %s canceled\", task_id)"
1069 },
1070 {
1071 "code": "def _superop_to_choi(data, input_dim, output_dim):\n shape = (output_dim, output_dim, input_dim, input_dim)\n return _reshuffle(data, shape)"
1072 },
1073 {
1074 "code": "def status(institute_id, case_name):\n institute_obj, case_obj = institute_and_case(store, institute_id, case_name)\n user_obj = store.user(current_user.email)\n status = request.form.get('status', case_obj['status'])\n link = url_for('.case', institute_id=institute_id, case_name=case_name)\n if status == 'archive':\n store.archive_case(institute_obj, case_obj, user_obj, status, link)\n else:\n store.update_status(institute_obj, case_obj, user_obj, status, link)\n return redirect(request.referrer)"
1075 },
1076 {
1077 "code": "def update_database(self, instance_id, database_id, ddl_statements,\n project_id=None,\n operation_id=None):\n instance = self._get_client(project_id=project_id).instance(\n instance_id=instance_id)\n if not instance.exists():\n raise AirflowException(\"The instance {} does not exist in project {} !\".\n format(instance_id, project_id))\n database = instance.database(database_id=database_id)\n try:\n operation = database.update_ddl(\n ddl_statements=ddl_statements, operation_id=operation_id)\n if operation:\n result = operation.result()\n self.log.info(result)\n return\n except AlreadyExists as e:\n if e.code == 409 and operation_id in e.message:\n self.log.info(\"Replayed update_ddl message - the operation id %s \"\n \"was already done before.\", operation_id)\n return\n except GoogleAPICallError as e:\n self.log.error('An error occurred: %s. Exiting.', e.message)\n raise e"
1078 },
1079 {
1080 "code": "def name(self):\n name = self._platform_impl.get_process_name()\n if os.name == 'posix':\n try:\n cmdline = self.cmdline\n except AccessDenied:\n pass\n else:\n if cmdline:\n extended_name = os.path.basename(cmdline[0])\n if extended_name.startswith(name):\n name = extended_name\n self._platform_impl._process_name = name\n return name"
1081 },
1082 {
1083 "code": "def create_group(self, group):\n self._valid_group_id(group.id)\n body = {\"data\": group.json_data()}\n url = \"{}/group/{}\".format(self.API, group.name)\n data = self._put_resource(url, headers={}, body=body)\n return self._group_from_json(data.get(\"data\"))"
1084 },
1085 {
1086 "code": "def _minimal_export_traces(self, outdir=None, analytes=None,\n samples=None, subset='All_Analyses'):\n if analytes is None:\n analytes = self.analytes\n elif isinstance(analytes, str):\n analytes = [analytes]\n if samples is not None:\n subset = self.make_subset(samples)\n samples = self._get_samples(subset)\n focus_stage = 'rawdata'\n if not os.path.isdir(outdir):\n os.mkdir(outdir)\n for s in samples:\n d = self.data[s].data[focus_stage]\n out = Bunch()\n for a in analytes:\n out[a] = d[a]\n out = pd.DataFrame(out, index=self.data[s].Time)\n out.index.name = 'Time'\n d = dateutil.parser.parse(self.data[s].meta['date'])\n header = ['\n (time.strftime('%Y:%m:%d %H:%M:%S')),\n \"\n '\n '\n '\n '\n header = '\\n'.join(header) + '\\n'\n csv = out.to_csv()\n with open('%s/%s.csv' % (outdir, s), 'w') as f:\n f.write(header)\n f.write(csv)\n return"
1087 },
1088 {
1089 "code": "def as_recarray(self):\n dtype = [(k,v.dtype) for k,v in self.__dict__.iteritems()]\n R = numpy.recarray(len(self.__dict__[k]),dtype=dtype)\n for key in self.__dict__:\n R[key] = self.__dict__[key]\n return R"
1090 },
1091 {
1092 "code": "def unregister(self, mimetype, processor):\n if mimetype in self and processor in self[mimetype]:\n self[mimetype].remove(processor)"
1093 },
1094 {
1095 "code": "def _write_iop_to_file(self, iop, file_name):\n lg.info('Writing :: ' + file_name)\n f = open(file_name, 'w')\n for i in scipy.nditer(iop):\n f.write(str(i) + '\\n')"
1096 },
1097 {
1098 "code": "async def get_tracks(self, *, limit: Optional[int] = 20, offset: Optional[int] = 0) -> List[Track]:\n data = await self.__client.http.album_tracks(self.id, limit=limit, offset=offset)\n return list(Track(self.__client, item) for item in data['items'])"
1099 },
1100 {
1101 "code": "def get_ammo_generator(self):\n af_readers = {\n 'phantom': missile.AmmoFileReader,\n 'slowlog': missile.SlowLogReader,\n 'line': missile.LineReader,\n 'uri': missile.UriReader,\n 'uripost': missile.UriPostReader,\n 'access': missile.AccessLogReader,\n 'caseline': missile.CaseLineReader,\n }\n if self.uris and self.ammo_file:\n raise StepperConfigurationError(\n 'Both uris and ammo file specified. You must specify only one of them'\n )\n elif self.uris:\n ammo_gen = missile.UriStyleGenerator(\n self.uris, self.headers, http_ver=self.http_ver)\n elif self.ammo_file:\n if self.ammo_type in af_readers:\n if self.ammo_type == 'phantom':\n opener = resource.get_opener(self.ammo_file)\n with opener(self.use_cache) as ammo:\n try:\n if not ammo.next()[0].isdigit():\n self.ammo_type = 'uri'\n self.log.info(\n \"Setting ammo_type 'uri' because ammo is not started with digit and you did not specify ammo format\"\n )\n else:\n self.log.info(\n \"Default ammo type ('phantom') used, use 'phantom.ammo_type' option to override it\"\n )\n except StopIteration:\n self.log.exception(\n \"Couldn't read first line of ammo file\")\n raise AmmoFileError(\n \"Couldn't read first line of ammo file\")\n else:\n raise NotImplementedError(\n 'No such ammo type implemented: \"%s\"' % self.ammo_type)\n ammo_gen = af_readers[self.ammo_type](\n self.ammo_file, headers=self.headers, http_ver=self.http_ver, use_cache=self.use_cache)\n else:\n raise StepperConfigurationError(\n 'Ammo not found. Specify uris or ammo file')\n self.log.info(\"Using %s ammo reader\" % type(ammo_gen).__name__)\n return ammo_gen"
1102 },
1103 {
1104 "code": "def check_rdd_dtype(rdd, expected_dtype):\n if not isinstance(rdd, BlockRDD):\n raise TypeError(\"Expected {0} for parameter rdd, got {1}.\"\n .format(BlockRDD, type(rdd)))\n if isinstance(rdd, DictRDD):\n if not isinstance(expected_dtype, dict):\n raise TypeError('Expected {0} for parameter '\n 'expected_dtype, got {1}.'\n .format(dict, type(expected_dtype)))\n accept = True\n types = dict(list(zip(rdd.columns, rdd.dtype)))\n for key, values in expected_dtype.items():\n if not isinstance(values, (tuple, list)):\n values = [values]\n accept = accept and types[key] in values\n return accept\n if not isinstance(expected_dtype, (tuple, list)):\n expected_dtype = [expected_dtype]\n return rdd.dtype in expected_dtype"
1105 },
1106 {
1107 "code": "def entropy(state):\n rho = np.array(state)\n if rho.ndim == 1:\n return 0\n evals = np.maximum(np.linalg.eigvalsh(state), 0.)\n return shannon_entropy(evals, base=np.e)"
1108 },
1109 {
1110 "code": "def python_matches(self,text):\n if \".\" in text:\n try:\n matches = self.attr_matches(text)\n if text.endswith('.') and self.omit__names:\n if self.omit__names == 1:\n no__name = (lambda txt:\n re.match(r'.*\\.__.*?__',txt) is None)\n else:\n no__name = (lambda txt:\n re.match(r'.*\\._.*?',txt) is None)\n matches = filter(no__name, matches)\n except NameError:\n matches = []\n else:\n matches = self.global_matches(text)\n return matches"
1111 },
1112 {
1113 "code": "def subwave(wave, dep_name=None, indep_min=None, indep_max=None, indep_step=None):\n r\n ret = copy.copy(wave)\n if dep_name is not None:\n ret.dep_name = dep_name\n _bound_waveform(ret, indep_min, indep_max)\n pexdoc.addai(\"indep_step\", bool((indep_step is not None) and (indep_step <= 0)))\n exmsg = \"Argument `indep_step` is greater than independent vector range\"\n cond = bool(\n (indep_step is not None)\n and (indep_step > ret._indep_vector[-1] - ret._indep_vector[0])\n )\n pexdoc.addex(RuntimeError, exmsg, cond)\n if indep_step:\n indep_vector = _barange(indep_min, indep_max, indep_step)\n dep_vector = _interp_dep_vector(ret, indep_vector)\n ret._set_indep_vector(indep_vector, check=False)\n ret._set_dep_vector(dep_vector, check=False)\n return ret"
1114 },
1115 {
1116 "code": "def init_transformers(self):\n self._transformers = []\n for transformer_cls in _default_transformers:\n transformer_cls(\n shell=self.shell, prefilter_manager=self, config=self.config\n )"
1117 },
1118 {
1119 "code": "def _mode(self):\n return (self.mean_direction +\n tf.zeros_like(self.concentration)[..., tf.newaxis])"
1120 },
1121 {
1122 "code": "def _prepare_args_with_initial_vertex(objective_function,\n initial_vertex,\n step_sizes,\n objective_at_initial_vertex,\n batch_evaluate_objective):\n dim = tf.size(input=initial_vertex)\n num_vertices = dim + 1\n unit_vectors_along_axes = tf.reshape(\n tf.eye(dim, dim, dtype=initial_vertex.dtype.base_dtype),\n tf.concat([[dim], tf.shape(input=initial_vertex)], axis=0))\n simplex_face = initial_vertex + step_sizes * unit_vectors_along_axes\n simplex = tf.concat([tf.expand_dims(initial_vertex, axis=0),\n simplex_face], axis=0)\n num_evaluations = 0\n if objective_at_initial_vertex is None:\n objective_at_initial_vertex = objective_function(initial_vertex)\n num_evaluations += 1\n objective_at_simplex_face, num_evals = _evaluate_objective_multiple(\n objective_function, simplex_face, batch_evaluate_objective)\n num_evaluations += num_evals\n objective_at_simplex = tf.concat(\n [\n tf.expand_dims(objective_at_initial_vertex, axis=0),\n objective_at_simplex_face\n ], axis=0)\n return (dim,\n num_vertices,\n simplex,\n objective_at_simplex,\n num_evaluations)"
1123 },
1124 {
1125 "code": "def convertBits(self, sigOrVal, toType):\n if isinstance(sigOrVal, Value):\n return convertBits__val(self, sigOrVal, toType)\n elif isinstance(toType, HBool):\n if self.bit_length() == 1:\n v = 0 if sigOrVal._dtype.negated else 1\n return sigOrVal._eq(self.getValueCls().fromPy(v, self))\n elif isinstance(toType, Bits):\n if self.bit_length() == toType.bit_length():\n return sigOrVal._convSign(toType.signed)\n elif toType == INT:\n return Operator.withRes(AllOps.BitsToInt, [sigOrVal], toType)\n return default_auto_cast_fn(self, sigOrVal, toType)"
1126 },
1127 {
1128 "code": "def from_symbol(cls, symbol):\n if symbol.lower() == symbol:\n return cls(PIECE_SYMBOLS.index(symbol), WHITE)\n else:\n return cls(PIECE_SYMBOLS.index(symbol.lower()), BLACK)"
1129 },
1130 {
1131 "code": "def pauli_group(number_of_qubits, case='weight'):\n if number_of_qubits < 5:\n temp_set = []\n if case == 'weight':\n tmp = pauli_group(number_of_qubits, case='tensor')\n return sorted(tmp, key=lambda x: -np.count_nonzero(\n np.array(x.to_label(), 'c') == b'I'))\n elif case == 'tensor':\n for k in range(4 ** number_of_qubits):\n z = np.zeros(number_of_qubits, dtype=np.bool)\n x = np.zeros(number_of_qubits, dtype=np.bool)\n for j in range(number_of_qubits):\n element = (k // (4 ** j)) % 4\n if element == 1:\n x[j] = True\n elif element == 2:\n z[j] = True\n x[j] = True\n elif element == 3:\n z[j] = True\n temp_set.append(Pauli(z, x))\n return temp_set\n else:\n raise QiskitError(\"Only support 'weight' or 'tensor' cases \"\n \"but you have {}.\".format(case))\n raise QiskitError(\"Only support number of qubits is less than 5\")"
1132 },
1133 {
1134 "code": "def _validate(self, qobj):\n n_qubits = qobj.config.n_qubits\n max_qubits = self.configuration().n_qubits\n if n_qubits > max_qubits:\n raise BasicAerError('Number of qubits {} '.format(n_qubits) +\n 'is greater than maximum ({}) '.format(max_qubits) +\n 'for \"{}\".'.format(self.name()))\n for experiment in qobj.experiments:\n name = experiment.header.name\n if experiment.config.memory_slots == 0:\n logger.warning('No classical registers in circuit \"%s\", '\n 'counts will be empty.', name)\n elif 'measure' not in [op.name for op in experiment.instructions]:\n logger.warning('No measurements in circuit \"%s\", '\n 'classical register will remain all zeros.', name)"
1135 },
1136 {
1137 "code": "def classification(self, classification):\n allowed_values = [\"Public Limited Indian Non-Government Company\", \"Private Limited Indian Non-Government Company\", \"One Person Company\", \"Private Limited Foreign Company Incorporated in India\", \"Public Limited Foreign Company Incorporated in India\", \"Union Government Company\", \"State Government Company\", \"Guarantee & Association Public\", \"Guarantee & Association Private\", \"Not For Profit Company\", \"Unlimited Liabilities Public\", \"Unlimited Liabilities Private\", \"Undefined\"]\n if classification not in allowed_values:\n raise ValueError(\n \"Invalid value for `classification`, must be one of {0}\"\n .format(allowed_values)\n )\n self._classification = classification"
1138 },
1139 {
1140 "code": "def val_where(cond, tval, fval):\n if isinstance(tval, tf.Tensor):\n return tf.where(cond, tval, fval)\n elif isinstance(tval, tuple):\n cls = type(tval)\n return cls(*(val_where(cond, t, f) for t, f in zip(tval, fval)))\n else:\n raise Exception(TypeError)"
1141 },
1142 {
1143 "code": "def get_embedding_levels(text, storage, upper_is_rtl=False, debug=False):\n prev_surrogate = False\n base_level = storage['base_level']\n for _ch in text:\n if _IS_UCS2 and (_SURROGATE_MIN <= ord(_ch) <= _SURROGATE_MAX):\n prev_surrogate = _ch\n continue\n elif prev_surrogate:\n _ch = prev_surrogate + _ch\n prev_surrogate = False\n if upper_is_rtl and _ch.isupper():\n bidi_type = 'R'\n else:\n bidi_type = bidirectional(_ch)\n storage['chars'].append({\n 'ch': _ch,\n 'level': base_level,\n 'type': bidi_type,\n 'orig': bidi_type\n })\n if debug:\n debug_storage(storage, base_info=True)"
1144 },
1145 {
1146 "code": "def load(self):\n self._check_open()\n try:\n data = json.load(self.file, **self.load_args)\n except ValueError:\n data = {}\n if not isinstance(data, dict):\n raise ValueError('Root JSON type must be dictionary')\n self.clear()\n self.update(data)"
1147 },
1148 {
1149 "code": "def calc(pvalues, lamb):\n m = len(pvalues)\n pi0 = (pvalues > lamb).sum() / ((1 - lamb)*m)\n pFDR = np.ones(m)\n print(\"pFDR y Pr fastPow\")\n for i in range(m):\n y = pvalues[i]\n Pr = max(1, m - i) / float(m)\n pFDR[i] = (pi0 * y) / (Pr * (1 - math.pow(1-y, m)))\n print(i, pFDR[i], y, Pr, 1.0 - math.pow(1-y, m))\n num_null = pi0*m\n num_alt = m - num_null\n num_negs = np.array(range(m))\n num_pos = m - num_negs\n pp = num_pos / float(m)\n qvalues = np.ones(m)\n qvalues[0] = pFDR[0]\n for i in range(m-1):\n qvalues[i+1] = min(qvalues[i], pFDR[i+1])\n sens = ((1.0 - qvalues) * num_pos) / num_alt\n sens[sens > 1.0] = 1.0\n df = pd.DataFrame(dict(\n pvalue=pvalues,\n qvalue=qvalues,\n FDR=pFDR,\n percentile_positive=pp,\n sens=sens\n ))\n df[\"svalue\"] = df.sens[::-1].cummax()[::-1]\n return df, num_null, m"
1150 },
1151 {
1152 "code": "def series(collection, method, prints = 15, *args, **kwargs):\n if 'verbose' in kwargs.keys():\n verbose = kwargs['verbose']\n else:\n verbose = True\n results = []\n timer = turntable.utils.Timer(nLoops=len(collection), numPrints=prints, verbose=verbose)\n for subject in collection:\n results.append(method(subject, *args, **kwargs))\n timer.loop()\n timer.fin()\n return results"
1153 },
1154 {
1155 "code": "def getlist(self, section, option):\n value_list = self.get(section, option)\n values = []\n for value_line in value_list.split('\\n'):\n for value in value_line.split(','):\n value = value.strip()\n if value:\n values.append(value)\n return values"
1156 },
1157 {
1158 "code": "def glob(self, pattern):\n cls = self.__class__\n return [cls(s) for s in glob.glob(unicode(self / pattern))]"
1159 },
1160 {
1161 "code": "def export_html(html, filename, image_tag = None, inline = True):\n if image_tag is None:\n image_tag = default_image_tag\n else:\n image_tag = ensure_utf8(image_tag)\n if inline:\n path = None\n else:\n root,ext = os.path.splitext(filename)\n path = root + \"_files\"\n if os.path.isfile(path):\n raise OSError(\"%s exists, but is not a directory.\" % path)\n with open(filename, 'w') as f:\n html = fix_html(html)\n f.write(IMG_RE.sub(lambda x: image_tag(x, path = path, format = \"png\"),\n html))"
1162 },
1163 {
1164 "code": "def export(self, cert, key, type=FILETYPE_PEM, days=100,\n digest=_UNSPECIFIED):\n if not isinstance(cert, X509):\n raise TypeError(\"cert must be an X509 instance\")\n if not isinstance(key, PKey):\n raise TypeError(\"key must be a PKey instance\")\n if not isinstance(type, int):\n raise TypeError(\"type must be an integer\")\n if digest is _UNSPECIFIED:\n raise TypeError(\"digest must be provided\")\n digest_obj = _lib.EVP_get_digestbyname(digest)\n if digest_obj == _ffi.NULL:\n raise ValueError(\"No such digest method\")\n bio = _lib.BIO_new(_lib.BIO_s_mem())\n _openssl_assert(bio != _ffi.NULL)\n sometime = _lib.ASN1_TIME_new()\n _openssl_assert(sometime != _ffi.NULL)\n _lib.X509_gmtime_adj(sometime, 0)\n _lib.X509_CRL_set_lastUpdate(self._crl, sometime)\n _lib.X509_gmtime_adj(sometime, days * 24 * 60 * 60)\n _lib.X509_CRL_set_nextUpdate(self._crl, sometime)\n _lib.X509_CRL_set_issuer_name(\n self._crl, _lib.X509_get_subject_name(cert._x509)\n )\n sign_result = _lib.X509_CRL_sign(self._crl, key._pkey, digest_obj)\n if not sign_result:\n _raise_current_error()\n return dump_crl(type, self)"
1165 },
1166 {
1167 "code": "def parse_text(text):\n assert isinstance(text, _str_type), \"`text` parameter should be a string, got %r\" % type(text)\n gen = iter(text.splitlines(True))\n readline = gen.next if hasattr(gen, \"next\") else gen.__next__\n return Code(_tokenize(readline))"
1168 },
1169 {
1170 "code": "def parsed_forensic_reports_to_csv(reports):\n fields = [\"feedback_type\", \"user_agent\", \"version\", \"original_envelope_id\",\n \"original_mail_from\", \"original_rcpt_to\", \"arrival_date\",\n \"arrival_date_utc\", \"subject\", \"message_id\",\n \"authentication_results\", \"dkim_domain\", \"source_ip_address\",\n \"source_country\", \"source_reverse_dns\", \"source_base_domain\",\n \"delivery_result\", \"auth_failure\", \"reported_domain\",\n \"authentication_mechanisms\", \"sample_headers_only\"]\n if type(reports) == OrderedDict:\n reports = [reports]\n csv_file = StringIO()\n csv_writer = DictWriter(csv_file, fieldnames=fields)\n csv_writer.writeheader()\n for report in reports:\n row = report.copy()\n row[\"source_ip_address\"] = report[\"source\"][\"ip_address\"]\n row[\"source_reverse_dns\"] = report[\"source\"][\"reverse_dns\"]\n row[\"source_base_domain\"] = report[\"source\"][\"base_domain\"]\n row[\"source_country\"] = report[\"source\"][\"country\"]\n del row[\"source\"]\n row[\"subject\"] = report[\"parsed_sample\"][\"subject\"]\n row[\"auth_failure\"] = \",\".join(report[\"auth_failure\"])\n authentication_mechanisms = report[\"authentication_mechanisms\"]\n row[\"authentication_mechanisms\"] = \",\".join(\n authentication_mechanisms)\n del row[\"sample\"]\n del row[\"parsed_sample\"]\n csv_writer.writerow(row)\n return csv_file.getvalue()"
1171 },
1172 {
1173 "code": "def print_processor_inputs(self, processor_name):\n p = self.processors(processor_name=processor_name)\n if len(p) == 1:\n p = p[0]\n else:\n Exception('Invalid processor name')\n for field_schema, _, _ in iterate_schema({}, p['input_schema'], 'input'):\n name = field_schema['name']\n typ = field_schema['type']\n print(\"{} -> {}\".format(name, typ))"
1174 },
1175 {
1176 "code": "def add_price_entity(self, price: dal.Price):\n from decimal import Decimal\n repo = self.get_price_repository()\n existing = (\n repo.query\n .filter(dal.Price.namespace == price.namespace)\n .filter(dal.Price.symbol == price.symbol)\n .filter(dal.Price.date == price.date)\n .filter(dal.Price.time == price.time)\n .first()\n )\n if existing:\n new_value = Decimal(price.value) / Decimal(price.denom)\n self.logger.info(f\"Exists: {price}\")\n if price.currency != existing.currency:\n raise ValueError(\n f\"The currency is different for price {price}!\")\n if existing.value != price.value:\n existing.value = price.value\n self.logger.info(f\"Updating to {new_value}.\")\n if existing.denom != price.denom:\n existing.denom = price.denom\n else:\n self.session.add(price)\n self.logger.info(f\"Added {price}\")"
1177 },
1178 {
1179 "code": "def _load_features_from_images(self, images, names=None):\n if names is not None and len(names) != len(images):\n raise Exception(\n \"Lists of feature names and images must be of same length!\")\n self.feature_names = names if names is not None else images\n self.feature_images = imageutils.load_imgs(images, self.masker)"
1180 },
1181 {
1182 "code": "def remove_chain(self, name):\n if name in self.chains:\n delattr(self.chains, name)\n else:\n raise ValueError(\"Chain with this name not found\")"
1183 },
1184 {
1185 "code": "def _use_rev_b_archive(self, records, offset):\n if type(self._ARCHIVE_REV_B) is bool:\n return self._ARCHIVE_REV_B\n data = ArchiveBStruct.unpack_from(records, offset)\n if data['RecType'] == 0:\n log.info('detected archive rev. B')\n self._ARCHIVE_REV_B = True\n else:\n log.info('detected archive rev. A')\n self._ARCHIVE_REV_B = False\n return self._ARCHIVE_REV_B"
1186 },
1187 {
1188 "code": "def do_help(self, options, args, parser):\n if options.help:\n if self.classic:\n self.help_fn(topic='help')\n else:\n self.help_fn(parser=parser)\n return True\n if \"help\" in options.actions:\n if args:\n for a in args:\n parser = CMDS.get(a)\n if parser:\n self.help_fn(parser=parser)\n else:\n self.help_fn(topic=a)\n else:\n self.help_fn(topic='help')\n return True\n if options.version:\n self.help_fn(topic='version')\n return True\n return False"
1189 },
1190 {
1191 "code": "def register_routes(app):\n from . import controllers\n from flask.blueprints import Blueprint\n for module in _import_submodules_from_package(controllers):\n bp = getattr(module, 'bp')\n if bp and isinstance(bp, Blueprint):\n app.register_blueprint(bp)"
1192 },
1193 {
1194 "code": "def flush(self, timeout=60):\n if timeout <= 0:\n raise ErrBadTimeout\n if self.is_closed:\n raise ErrConnectionClosed\n future = asyncio.Future(loop=self._loop)\n try:\n yield from self._send_ping(future)\n yield from asyncio.wait_for(future, timeout, loop=self._loop)\n except asyncio.TimeoutError:\n future.cancel()\n raise ErrTimeout"
1195 },
1196 {
1197 "code": "def match(self):\n result = []\n to_match = comp(self.regex)\n if self.rematch:\n pre_result = to_match.findall(self.data)\n else:\n pre_result = to_match.search(self.data)\n if self.return_data and pre_result:\n if self.rematch:\n for data in pre_result:\n if isinstance(data, tuple):\n result.extend(list(data))\n else:\n result.append(data)\n if self.group != 0:\n return result[self.group]\n else:\n result = pre_result.group(\n self.group\n ).strip()\n return result\n if not self.return_data and pre_result:\n return True\n return False"
1198 },
1199 {
1200 "code": "def reset(self, new_session=True):\n self.history_manager.reset(new_session)\n if new_session:\n self.execution_count = 1\n if self.displayhook.do_full_cache:\n self.displayhook.flush()\n if self.user_ns is not self.user_global_ns:\n self.user_ns.clear()\n ns = self.user_global_ns\n drop_keys = set(ns.keys())\n drop_keys.discard('__builtin__')\n drop_keys.discard('__builtins__')\n drop_keys.discard('__name__')\n for k in drop_keys:\n del ns[k]\n self.user_ns_hidden.clear()\n self.init_user_ns()\n self.alias_manager.clear_aliases()\n self.alias_manager.init_aliases()\n self.clear_main_mod_cache()\n self.new_main_mod()"