ShijiaD/workshop-code-docstring
010
1[
2 {
3 "code": "def _publish_instruction_as_executed(self, insn):\n self._icount += 1\n self._publish('did_execute_instruction', self._last_pc, self.PC, insn)"
4 },
5 {
6 "code": "def reset_lock(self):\n redis_key = self.CELERY_LOCK.format(task_id=self.task_identifier)\n self.celery_self.backend.client.delete(redis_key)"
7 },
8 {
9 "code": "def check_max_filesize(chosen_file, max_size):\n if os.path.getsize(chosen_file) > max_size:\n return False\n else:\n return True"
10 },
11 {
12 "code": "def _generate_index(self):\n self._dict = {v.id: k for k, v in enumerate(self)}"
13 },
14 {
15 "code": "def prepare_attrib_mapping(self, primitive):\n buffer_info = []\n for name, accessor in primitive.attributes.items():\n info = VBOInfo(*accessor.info())\n info.attributes.append((name, info.components))\n if buffer_info and buffer_info[-1].buffer_view == info.buffer_view:\n if buffer_info[-1].interleaves(info):\n buffer_info[-1].merge(info)\n continue\n buffer_info.append(info)\n return buffer_info"
16 },
17 {
18 "code": "def create_new_locale(\n self,\n template_id,\n locale,\n version_name,\n subject,\n text='',\n html='',\n timeout=None\n ):\n payload = {\n 'locale': locale,\n 'name': version_name,\n 'subject': subject\n }\n if html:\n payload['html'] = html\n if text:\n payload['text'] = text\n return self._api_request(\n self.TEMPLATES_LOCALES_ENDPOINT % template_id,\n self.HTTP_POST,\n payload=payload,\n timeout=timeout\n )"
19 },
20 {
21 "code": "def getZeroedOutEncoding(self, n):\n assert all(field.numRecords>n for field in self.fields)\n encoding = np.concatenate([field.encoder.encode(SENTINEL_VALUE_FOR_MISSING_DATA)\\\n if field.isPredictedField else field.encodings[n] for field in self.fields])\n return encoding"
22 },
23 {
24 "code": "def angle(x0, y0, x1, y1):\r\n return degrees(atan2(y1-y0, x1-x0))"
25 },
26 {
27 "code": "def read_value(self):\n pass\n self._value_read.clear()\n self._device._peripheral.readValueForDescriptor(self._descriptor)\n if not self._value_read.wait(timeout_sec):\n raise RuntimeError('Exceeded timeout waiting to read characteristic value!')\n return self._value"
28 },
29 {
30 "code": "def find_chunk (phrase, np):\n for i in iter(range(0, len(phrase))):\n parsed_np = find_chunk_sub(phrase, np, i)\n if parsed_np:\n return parsed_np"
31 },
32 {
33 "code": "def fluent(func):\n @wraps(func)\n def fluent_interface(instance, *args, **kwargs):\n ret = func(instance, *args, **kwargs)\n if ret is not None:\n return ret\n return instance\n return fluent_interface"
34 },
35 {
36 "code": "def _generalized_word_starts(self, xs):\n self.word_starts = []\n i = 0\n for n in range(len(xs)):\n self.word_starts.append(i)\n i += len(xs[n]) + 1"
37 },
38 {
39 "code": "def modify_input():\n doc_mapper = DocMapper()\n if doc_mapper.is_pipe:\n objects = [obj for obj in doc_mapper.get_pipe()]\n modified = modify_data(objects)\n for line in modified:\n obj = doc_mapper.line_to_object(line)\n obj.save()\n print_success(\"Object(s) successfully changed\")\n else:\n print_error(\"Please use this tool with pipes\")"
40 },
41 {
42 "code": "def course_enrollments(self, request, pk):\n enterprise_customer = self.get_object()\n serializer = serializers.EnterpriseCustomerCourseEnrollmentsSerializer(\n data=request.data,\n many=True,\n context={\n 'enterprise_customer': enterprise_customer,\n 'request_user': request.user,\n }\n )\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=HTTP_200_OK)\n return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)"
43 },
44 {
45 "code": "def mods_genre(self):\n\t\ttype2genre = {\n\t\t\t\t'conference': 'conference publication',\n\t\t\t\t'book chapter': 'bibliography',\n\t\t\t\t'unpublished': 'article'\n\t\t\t}\n\t\ttp = str(self.type).lower()\n\t\treturn type2genre.get(tp, tp)"
46 },
47 {
48 "code": "def _remove_default_tz_bindings(self, context, network_id):\n default_tz = CONF.NVP.default_tz\n if not default_tz:\n LOG.warn(\"additional_default_tz_types specified, \"\n \"but no default_tz. Skipping \"\n \"_remove_default_tz_bindings().\")\n return\n if not network_id:\n LOG.warn(\"neutron network_id not specified, skipping \"\n \"_remove_default_tz_bindings()\")\n return\n for net_type in CONF.NVP.additional_default_tz_types:\n if net_type in TZ_BINDINGS:\n binding = TZ_BINDINGS[net_type]\n binding.remove(context, default_tz, network_id)\n else:\n LOG.warn(\"Unknown default tz type %s\" % (net_type))"
49 },
50 {
51 "code": "def _convert(value, to_type, default=None):\n try:\n return default if value is None else to_type(value)\n except ValueError:\n return default"
52 },
53 {
54 "code": "def paths_from_env(prefix=None, names=None):\n def expand_path(path):\n return os.path.abspath(os.path.expanduser(os.path.expandvars(path)))\n if prefix is None:\n prefix = \"CIJ\"\n if names is None:\n names = [\n \"ROOT\", \"ENVS\", \"TESTPLANS\", \"TESTCASES\", \"TESTSUITES\", \"MODULES\",\n \"HOOKS\", \"TEMPLATES\"\n ]\n conf = {v: os.environ.get(\"_\".join([prefix, v])) for v in names}\n for env in (e for e in conf.keys() if e[:len(prefix)] in names and conf[e]):\n conf[env] = expand_path(conf[env])\n if not os.path.exists(conf[env]):\n err(\"%s_%s: %r, does not exist\" % (prefix, env, conf[env]))\n return conf"
55 },
56 {
57 "code": "def _configure_users(self, site=None, full=0, only_data=0):\n site = site or ALL\n full = int(full)\n if full and not only_data:\n packager = self.get_satchel('packager')\n packager.install_required(type=SYSTEM, service=self.name)\n r = self.local_renderer\n params = self.get_user_vhosts(site=site)\n with settings(warn_only=True):\n self.add_admin_user()\n params = sorted(list(params))\n if not only_data:\n for user, password, vhost in params:\n r.env.broker_user = user\n r.env.broker_password = password\n r.env.broker_vhost = vhost\n with settings(warn_only=True):\n r.sudo('rabbitmqctl add_user {broker_user} {broker_password}')\n r.sudo('rabbitmqctl add_vhost {broker_vhost}')\n r.sudo('rabbitmqctl set_permissions -p {broker_vhost} {broker_user} \".*\" \".*\" \".*\"')\n r.sudo('rabbitmqctl set_permissions -p {broker_vhost} {admin_username} \".*\" \".*\" \".*\"')\n return params"
58 },
59 {
60 "code": "def str_cmd(cmd, cwd, env):\n process = subprocess.Popen(cmd, stdout=subprocess.PIPE,\n stderr=subprocess.PIPE, cwd=cwd, env=env)\n stdout_builder, stderr_builder = proc.async_stdout_stderr_builder(process)\n process.wait()\n stdout, stderr = stdout_builder.result(), stderr_builder.result()\n return {'command': ' '.join(cmd), 'stderr': stderr, 'stdout': stdout}"
61 },
62 {
63 "code": "def filter_dict(unfiltered, filter_keys):\n filtered = DotDict()\n for k in filter_keys:\n filtered[k] = unfiltered[k]\n return filtered"
64 },
65 {
66 "code": "def validate(self):\n warnings.warn(\n 'Property \"package.validate\" is deprecated.',\n UserWarning)\n descriptor = self.to_dict()\n self.profile.validate(descriptor)"
67 },
68 {
69 "code": "def _cleanup_and_die(data):\n tmpfiles = glob.glob(os.path.join(data.dirs.fastqs, \"tmp_*_R*.fastq\"))\n tmpfiles += glob.glob(os.path.join(data.dirs.fastqs, \"tmp_*.p\"))\n for tmpf in tmpfiles: \n os.remove(tmpf)"
70 },
71 {
72 "code": "def run(cmd, **kw):\n kw = kw.copy()\n kw.setdefault('warn', False)\n report_error = kw.pop('report_error', True)\n runner = kw.pop('runner', invoke_run)\n try:\n return runner(cmd, **kw)\n except exceptions.Failure as exc:\n sys.stdout.flush()\n sys.stderr.flush()\n if report_error:\n notify.error(\"Command `{}` failed with RC={}!\".format(cmd, exc.result.return_code,))\n raise\n finally:\n sys.stdout.flush()\n sys.stderr.flush()"
73 },
74 {
75 "code": "def expand_args(command):\n if isinstance(command, (str, unicode)):\n splitter = shlex.shlex(command.encode('utf-8'))\n splitter.whitespace = '|'\n splitter.whitespace_split = True\n command = []\n while True:\n token = splitter.get_token()\n if token:\n command.append(token)\n else:\n break\n command = list(map(shlex.split, command))\n return command"
76 },
77 {
78 "code": "def next_item(self):\n queue = self.queue\n try:\n item = queue.get(block=True, timeout=5)\n return item\n except Exception:\n return None"
79 },
80 {
81 "code": "def rem_active_module(module):\n modules = set(get_active_modules())\n modules.discard(module)\n new_modules_path = os.pathsep.join([m.path for m in modules])\n os.environ['CPENV_ACTIVE_MODULES'] = str(new_modules_path)"
82 },
83 {
84 "code": "def parse(filename):\n for event, elt in et.iterparse(filename, events= ('start', 'end', 'comment', 'pi'), huge_tree=True):\n if event == 'start':\n obj = _elt2obj(elt)\n obj['type'] = ENTER\n yield obj\n if elt.text:\n yield {'type': TEXT, 'text': elt.text}\n elif event == 'end':\n yield {'type': EXIT}\n if elt.tail:\n yield {'type': TEXT, 'text': elt.tail}\n elt.clear()\n elif event == 'comment':\n yield {'type': COMMENT, 'text': elt.text}\n elif event == 'pi':\n yield {'type': PI, 'text': elt.text}\n else:\n assert False, (event, elt)"
85 },
86 {
87 "code": "def showfig(fig, aspect=\"auto\"):\n ax = fig.gca()\n alim = list(ax.axis())\n if alim[3] < alim[2]:\n temp = alim[2]\n alim[2] = alim[3]\n alim[3] = temp\n ax.axis(alim)\n ax.set_aspect(aspect)\n fig.show()"
88 },
89 {
90 "code": "def _echo_setting(key):\n value = getattr(settings, key)\n secho('%s: ' % key, fg='magenta', bold=True, nl=False)\n secho(\n six.text_type(value),\n bold=True,\n fg='white' if isinstance(value, six.text_type) else 'cyan',\n )"
91 },
92 {
93 "code": "def _destroy_image_acquirer(self, ia):\n id_ = None\n if ia.device:\n ia.stop_image_acquisition()\n ia._release_data_streams()\n id_ = ia._device.id_\n if ia.device.node_map:\n if ia._chunk_adapter:\n ia._chunk_adapter.detach_buffer()\n ia._chunk_adapter = None\n self._logger.info(\n 'Detached a buffer from the chunk adapter of {0}.'.format(\n id_\n )\n )\n ia.device.node_map.disconnect()\n self._logger.info(\n 'Disconnected the port from the NodeMap of {0}.'.format(\n id_\n )\n )\n if ia._device.is_open():\n ia._device.close()\n self._logger.info(\n 'Closed Device module, {0}.'.format(id_)\n )\n ia._device = None\n if id_:\n self._logger.info(\n 'Destroyed the ImageAcquirer object which {0} '\n 'had belonged to.'.format(id_)\n )\n else:\n self._logger.info(\n 'Destroyed an ImageAcquirer.'\n )\n if self._profiler:\n self._profiler.print_diff()\n self._ias.remove(ia)"
94 },
95 {
96 "code": "def _fmt_args_kwargs(self, *some_args, **some_kwargs):\n if some_args:\n out_args = str(some_args).lstrip('(').rstrip(',)')\n if some_kwargs:\n out_kwargs = ', '.join([str(i).lstrip('(').rstrip(')').replace(', ',': ') for i in [\n (k,some_kwargs[k]) for k in sorted(some_kwargs.keys())]])\n if some_args and some_kwargs:\n return out_args + ', ' + out_kwargs\n elif some_args:\n return out_args\n elif some_kwargs:\n return out_kwargs\n else:\n return ''"
97 },
98 {
99 "code": "def pad_cells(table):\n col_sizes = [max(map(len, col)) for col in zip(*table)]\n for row in table:\n for cell_num, cell in enumerate(row):\n row[cell_num] = pad_to(cell, col_sizes[cell_num])\n return table"
100 },
101 {
102 "code": "def _add_document(self, doc_id, conn=None, nosave=False, score=1.0, payload=None,\n replace=False, partial=False, language=None, **fields):\n if conn is None:\n conn = self.redis\n if partial:\n replace = True\n args = [self.ADD_CMD, self.index_name, doc_id, score]\n if nosave:\n args.append('NOSAVE')\n if payload is not None:\n args.append('PAYLOAD')\n args.append(payload)\n if replace:\n args.append('REPLACE')\n if partial:\n args.append('PARTIAL')\n if language:\n args += ['LANGUAGE', language]\n args.append('FIELDS')\n args += list(itertools.chain(*fields.items()))\n return conn.execute_command(*args)"
103 },
104 {
105 "code": "def exploit_single(self, ip, operating_system):\n result = None\n if \"Windows Server 2008\" in operating_system or \"Windows 7\" in operating_system:\n result = subprocess.run(['python2', os.path.join(self.datadir, 'MS17-010', 'eternalblue_exploit7.py'), str(ip), os.path.join(self.datadir, 'final_combined.bin'), \"12\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n elif \"Windows Server 2012\" in operating_system or \"Windows 10\" in operating_system or \"Windows 8.1\" in operating_system:\n result = subprocess.run(['python2', os.path.join(self.datadir, 'MS17-010', 'eternalblue_exploit8.py'), str(ip), os.path.join(self.datadir, 'final_combined.bin'), \"12\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n else:\n return [\"System target could not be automatically identified\"]\n return result.stdout.decode('utf-8').split('\\n')"
106 },
107 {
108 "code": "def commit(self, *args, **kwargs):\n return super(Deposit, self).commit(*args, **kwargs)"
109 },
110 {
111 "code": "def ternary_operation(x):\n g = tf.get_default_graph()\n with g.gradient_override_map({\"Sign\": \"Identity\"}):\n threshold = _compute_threshold(x)\n x = tf.sign(tf.add(tf.sign(tf.add(x, threshold)), tf.sign(tf.add(x, -threshold))))\n return x"
112 },
113 {
114 "code": "def centralManager_didDisconnectPeripheral_error_(self, manager, peripheral, error):\n logger.debug('centralManager_didDisconnectPeripheral called')\n device = device_list().get(peripheral)\n if device is not None:\n device._set_disconnected()\n device_list().remove(peripheral)"
115 },
116 {
117 "code": "def track_enrollment(pathway, user_id, course_run_id, url_path=None):\n track_event(user_id, 'edx.bi.user.enterprise.onboarding', {\n 'pathway': pathway,\n 'url_path': url_path,\n 'course_run_id': course_run_id,\n })"
118 },
119 {
120 "code": "def addInstance(self, groundTruth, prediction, record = None, result = None):\n self.value = self.avg(prediction)"
121 },
122 {
123 "code": "def keypress(self, size, key):\n key = super().keypress(size, key)\n num_tabs = len(self._widgets)\n if key == self._keys['prev_tab']:\n self._tab_index = (self._tab_index - 1) % num_tabs\n self._update_tabs()\n elif key == self._keys['next_tab']:\n self._tab_index = (self._tab_index + 1) % num_tabs\n self._update_tabs()\n elif key == self._keys['close_tab']:\n if self._tab_index > 0:\n curr_tab = self._widgets[self._tab_index]\n self._widgets.remove(curr_tab)\n del self._widget_title[curr_tab]\n self._tab_index -= 1\n self._update_tabs()\n else:\n return key"
124 },
125 {
126 "code": "def send(self, dispatcher):\n if self.sent_complete:\n return\n sent = dispatcher.send(self.to_send)\n self.to_send = self.to_send[sent:]"
127 },
128 {
129 "code": "def _get_prepare_env(self, script, job_descriptor, inputs, outputs, mounts):\n docker_paths = sorted([\n var.docker_path if var.recursive else os.path.dirname(var.docker_path)\n for var in inputs | outputs | mounts\n if var.value\n ])\n env = {\n _SCRIPT_VARNAME: repr(script.value),\n _META_YAML_VARNAME: repr(job_descriptor.to_yaml()),\n 'DIR_COUNT': str(len(docker_paths))\n }\n for idx, path in enumerate(docker_paths):\n env['DIR_{}'.format(idx)] = os.path.join(providers_util.DATA_MOUNT_POINT,\n path)\n return env"
130 },
131 {
132 "code": "def _compute(self, inputs, outputs):\n if self._sfdr is None:\n raise RuntimeError(\"Spatial pooler has not been initialized\")\n if not self.topDownMode:\n self._iterations += 1\n buInputVector = inputs['bottomUpIn']\n resetSignal = False\n if 'resetIn' in inputs:\n assert len(inputs['resetIn']) == 1\n resetSignal = inputs['resetIn'][0] != 0\n rfOutput = self._doBottomUpCompute(\n rfInput = buInputVector.reshape((1,buInputVector.size)),\n resetSignal = resetSignal\n )\n outputs['bottomUpOut'][:] = rfOutput.flat\n else:\n topDownIn = inputs.get('topDownIn',None)\n spatialTopDownOut, temporalTopDownOut = self._doTopDownInfer(topDownIn)\n outputs['spatialTopDownOut'][:] = spatialTopDownOut\n if temporalTopDownOut is not None:\n outputs['temporalTopDownOut'][:] = temporalTopDownOut\n outputs['anomalyScore'][:] = 0"
133 },
134 {
135 "code": "def word_to_id(self, word):\n if word in self.vocab:\n return self.vocab[word]\n else:\n return self.unk_id"
136 },
137 {
138 "code": "def link_zscale(st):\n psf = st.get('psf')\n psf.param_dict['zscale'] = psf.param_dict['psf-zscale']\n psf.params[psf.params.index('psf-zscale')] = 'zscale'\n psf.global_zscale = True\n psf.param_dict.pop('psf-zscale')\n st.trigger_parameter_change()\n st.reset()"
139 },
140 {
141 "code": "def _getEphemeralMembers(self):\n e = BacktrackingTM._getEphemeralMembers(self)\n if self.makeCells4Ephemeral:\n e.extend(['cells4'])\n return e"
142 },
143 {
144 "code": "def check(self):\n if not self.is_valid:\n raise PolyaxonDeploymentConfigError(\n 'Deployment type `{}` not supported'.format(self.deployment_type))\n check = False\n if self.is_kubernetes:\n check = self.check_for_kubernetes()\n elif self.is_docker_compose:\n check = self.check_for_docker_compose()\n elif self.is_docker:\n check = self.check_for_docker()\n elif self.is_heroku:\n check = self.check_for_heroku()\n if not check:\n raise PolyaxonDeploymentConfigError(\n 'Deployment `{}` is not valid'.format(self.deployment_type))"
145 },
146 {
147 "code": "def write(self, album):\n page = self.template.render(**self.generate_context(album))\n output_file = os.path.join(album.dst_path, album.output_file)\n with open(output_file, 'w', encoding='utf-8') as f:\n f.write(page)"
148 },
149 {
150 "code": "def _rebuildPartitionIdMap(self, partitionIdList):\n self._partitionIdMap = {}\n for row, partitionId in enumerate(partitionIdList):\n indices = self._partitionIdMap.get(partitionId, [])\n indices.append(row)\n self._partitionIdMap[partitionId] = indices"
151 },
152 {
153 "code": "def end(self):\n return Range(self.source_buffer, self.end_pos, self.end_pos,\n expanded_from=self.expanded_from)"
154 },
155 {
156 "code": "def _sample_with_priority(self, p):\n parent = 0\n while True:\n left = 2 * parent + 1\n if left >= len(self._memory):\n return parent\n left_p = self._memory[left] if left < self._capacity - 1 \\\n else (self._memory[left].priority or 0)\n if p <= left_p:\n parent = left\n else:\n if left + 1 >= len(self._memory):\n raise RuntimeError('Right child is expected to exist.')\n p -= left_p\n parent = left + 1"
157 },
158 {
159 "code": "def merge_da(self):\n print(' - Merging D and A timestamps', flush=True)\n ts_d, ts_par_d = self.S.get_timestamps_part(self.name_timestamps_d)\n ts_a, ts_par_a = self.S.get_timestamps_part(self.name_timestamps_a)\n ts, a_ch, part = merge_da(ts_d, ts_par_d, ts_a, ts_par_a)\n assert a_ch.sum() == ts_a.shape[0]\n assert (~a_ch).sum() == ts_d.shape[0]\n assert a_ch.size == ts_a.shape[0] + ts_d.shape[0]\n self.ts, self.a_ch, self.part = ts, a_ch, part\n self.clk_p = ts_d.attrs['clk_p']"
160 },
161 {
162 "code": "def _httplib2_init(username, password):\n obj = httplib2.Http()\n if username and password:\n obj.add_credentials(username, password)\n return obj"
163 },
164 {
165 "code": "def _setVirtualEnv():\n try:\n activate = options.virtualenv.activate_cmd\n except AttributeError:\n activate = None\n if activate is None:\n virtualenv = path(os.environ.get('VIRTUAL_ENV', ''))\n if not virtualenv:\n virtualenv = options.paved.cwd\n else:\n virtualenv = path(virtualenv)\n activate = virtualenv / 'bin' / 'activate'\n if activate.exists():\n info('Using default virtualenv at %s' % activate)\n options.setdotted('virtualenv.activate_cmd', 'source %s' % activate)"
166 },
167 {
168 "code": "def settings(self):\n for table in self.tables:\n if isinstance(table, SettingTable):\n for statement in table.statements:\n yield statement"
169 },
170 {
171 "code": "def on_new(self):\n interpreter, pyserver, args = self._get_backend_parameters()\n self.setup_editor(self.tabWidget.create_new_document(\n extension='.py', interpreter=interpreter, server_script=pyserver,\n args=args))\n self.actionRun.setDisabled(True)\n self.actionConfigure_run.setDisabled(True)"
172 },
173 {
174 "code": "def build_sdist(sdist_directory, config_settings):\n backend = _build_backend()\n try:\n return backend.build_sdist(sdist_directory, config_settings)\n except getattr(backend, 'UnsupportedOperation', _DummyException):\n raise GotUnsupportedOperation(traceback.format_exc())"
175 },
176 {
177 "code": "def from_separate(cls, meta: ProgramDescription, vertex_source, geometry_source=None, fragment_source=None,\r\n tess_control_source=None, tess_evaluation_source=None):\r\n instance = cls(meta)\r\n instance.vertex_source = ShaderSource(\r\n VERTEX_SHADER,\r\n meta.path or meta.vertex_shader,\r\n vertex_source,\r\n )\r\n if geometry_source:\r\n instance.geometry_source = ShaderSource(\r\n GEOMETRY_SHADER,\r\n meta.path or meta.geometry_shader,\r\n geometry_source,\r\n )\r\n if fragment_source:\r\n instance.fragment_source = ShaderSource(\r\n FRAGMENT_SHADER,\r\n meta.path or meta.fragment_shader,\r\n fragment_source,\r\n )\r\n if tess_control_source:\r\n instance.tess_control_source = ShaderSource(\r\n TESS_CONTROL_SHADER,\r\n meta.path or meta.tess_control_shader,\r\n tess_control_source,\r\n )\r\n if tess_evaluation_source:\r\n instance.tess_evaluation_source = ShaderSource(\r\n TESS_EVALUATION_SHADER,\r\n meta.path or meta.tess_control_shader,\r\n tess_evaluation_source,\r\n )\r\n return instance"
178 },
179 {
180 "code": "def format_objects(objects, children=False, columns=None, header=True):\n columns = columns or ('NAME', 'TYPE', 'PATH')\n objects = sorted(objects, key=_type_and_name)\n data = []\n for obj in objects:\n if isinstance(obj, cpenv.VirtualEnvironment):\n data.append(get_info(obj))\n modules = obj.get_modules()\n if children and modules:\n for mod in modules:\n data.append(get_info(mod, indent=2, root=obj.path))\n else:\n data.append(get_info(obj))\n maxes = [len(max(col, key=len)) for col in zip(*data)]\n tmpl = '{:%d} {:%d} {:%d}' % tuple(maxes)\n lines = []\n if header:\n lines.append('\\n' + bold_blue(tmpl.format(*columns)))\n for obj_data in data:\n lines.append(tmpl.format(*obj_data))\n return '\\n'.join(lines)"
181 },
182 {
183 "code": "def index():\n page = request.args.get('page', 1, type=int)\n per_page = request.args.get('per_page', 5, type=int)\n q = request.args.get('q', '')\n groups = Group.query_by_user(current_user, eager=True)\n if q:\n groups = Group.search(groups, q)\n groups = groups.paginate(page, per_page=per_page)\n requests = Membership.query_requests(current_user).count()\n invitations = Membership.query_invitations(current_user).count()\n return render_template(\n 'invenio_groups/index.html',\n groups=groups,\n requests=requests,\n invitations=invitations,\n page=page,\n per_page=per_page,\n q=q\n )"
184 },
185 {
186 "code": "def _get_contour_values(min_val, max_val, base=0, interval=100):\n i = base\n out = []\n if min_val < base:\n while i >= min_val:\n i -= interval\n while i <= max_val:\n if i >= min_val:\n out.append(i)\n i += interval\n return out"
187 },
188 {
189 "code": "def intersection(self, i):\n if self.intersects(i):\n return Interval(max(self.start, i.start), min(self.end, i.end))\n else:\n return None"
190 },
191 {
192 "code": "def wait_for_page_to_load(self):\n self.wait.until(lambda _: self.loaded)\n self.pm.hook.pypom_after_wait_for_page_to_load(page=self)\n return self"
193 },
194 {
195 "code": "def with_access_to(self, request, *args, **kwargs):\n self.queryset = self.queryset.order_by('name')\n enterprise_id = self.request.query_params.get('enterprise_id', None)\n enterprise_slug = self.request.query_params.get('enterprise_slug', None)\n enterprise_name = self.request.query_params.get('search', None)\n if enterprise_id is not None:\n self.queryset = self.queryset.filter(uuid=enterprise_id)\n elif enterprise_slug is not None:\n self.queryset = self.queryset.filter(slug=enterprise_slug)\n elif enterprise_name is not None:\n self.queryset = self.queryset.filter(name__icontains=enterprise_name)\n return self.list(request, *args, **kwargs)"
196 },
197 {
198 "code": "def push(self, ip_packet):\n data_len = len(ip_packet.data.data)\n seq_id = ip_packet.data.seq\n if data_len == 0:\n self._next_seq_id = seq_id\n return False\n if self._next_seq_id != -1 and seq_id != self._next_seq_id:\n return False\n self._next_seq_id = seq_id + data_len\n with self._lock_packets:\n self._length += len(ip_packet.data.data)\n self._remaining += len(ip_packet.data.data)\n self._packets.append(ip_packet)\n return True"
199 },
200 {
201 "code": "def do_toggle_variables(self, action):\n self.show_vars = action.get_active()\n if self.show_vars:\n self.show_variables_window()\n else:\n self.hide_variables_window()"
202 },
203 {
204 "code": "def _validate_ram(ram_in_mb):\n return int(GoogleV2CustomMachine._MEMORY_MULTIPLE * math.ceil(\n ram_in_mb / GoogleV2CustomMachine._MEMORY_MULTIPLE))"
205 },
206 {
207 "code": "def _arg_parser():\n description = \"Converts a completezip to a litezip\"\n parser = argparse.ArgumentParser(description=description)\n verbose_group = parser.add_mutually_exclusive_group()\n verbose_group.add_argument(\n '-v', '--verbose', action='store_true',\n dest='verbose', default=None,\n help=\"increase verbosity\")\n verbose_group.add_argument(\n '-q', '--quiet', action='store_false',\n dest='verbose', default=None,\n help=\"print nothing to stdout or stderr\")\n parser.add_argument(\n 'location',\n help=\"Location of the unpacked litezip\")\n return parser"
208 },
209 {
210 "code": "def with_logger(cls):\n attr_name = '_logger'\n cls_name = cls.__qualname__\n module = cls.__module__\n if module is not None:\n cls_name = module + '.' + cls_name\n else:\n raise AssertionError\n setattr(cls, attr_name, logging.getLogger(cls_name))\n return cls"
211 },
212 {
213 "code": "def _f_gene(sid, prefix=\"G_\"):\n sid = sid.replace(SBML_DOT, \".\")\n return _clip(sid, prefix)"
214 },
215 {
216 "code": "def getInstanceJstack(self, topology_info, instance_id):\n pid_response = yield getInstancePid(topology_info, instance_id)\n try:\n http_client = tornado.httpclient.AsyncHTTPClient()\n pid_json = json.loads(pid_response)\n pid = pid_json['stdout'].strip()\n if pid == '':\n raise Exception('Failed to get pid')\n endpoint = utils.make_shell_endpoint(topology_info, instance_id)\n url = \"%s/jstack/%s\" % (endpoint, pid)\n response = yield http_client.fetch(url)\n Log.debug(\"HTTP call for url: %s\", url)\n raise tornado.gen.Return(response.body)\n except tornado.httpclient.HTTPError as e:\n raise Exception(str(e))"
217 },
218 {
219 "code": "def answer_display(self, s=''):\n padding = len(max(self.questions.keys(), key=len)) + 5\n for key in list(self.answers.keys()):\n s += '{:>{}} : {}\\n'.format(key, padding, self.answers[key])\n return s"
220 },
221 {
222 "code": "def pickle_save(thing,fname):\n pickle.dump(thing, open(fname,\"wb\"),pickle.HIGHEST_PROTOCOL)\n return thing"
223 },
224 {
225 "code": "def utime(self, *args, **kwargs):\n os.utime(self.extended_path, *args, **kwargs)"
226 },
227 {
228 "code": "def map_memory_callback(self, address, size, perms, name, offset, result):\n logger.info(' '.join((\"Mapping Memory @\",\n hex(address) if type(address) is int else \"0x??\",\n hr_size(size), \"-\",\n perms, \"-\",\n f\"{name}:{hex(offset) if name else ''}\", \"->\",\n hex(result))))\n self._emu.mem_map(address, size, convert_permissions(perms))\n self.copy_memory(address, size)"
229 },
230 {
231 "code": "def tool_factory(clsname, name, driver, base=GromacsCommand):\n clsdict = {\n 'command_name': name,\n 'driver': driver,\n '__doc__': property(base._get_gmx_docs)\n }\n return type(clsname, (base,), clsdict)"
232 },
233 {
234 "code": "def _xml(self, root):\n element = root.createElement(self.name)\n keys = self.attrs.keys()\n keys.sort()\n for a in keys:\n element.setAttribute(a, self.attrs[a])\n if self.body:\n text = root.createTextNode(self.body)\n element.appendChild(text)\n for c in self.elements:\n element.appendChild(c._xml(root))\n return element"
235 },
236 {
237 "code": "def operation_list(uploader):\n files = uploader.file_list()\n for f in files:\n log.info(\"{file:30s} {size}\".format(file=f[0], size=f[1]))"
238 },
239 {
240 "code": "def jobCancelAllRunningJobs(self):\n with ConnectionFactory.get() as conn:\n query = 'UPDATE %s SET cancel=TRUE WHERE status<>%%s ' \\\n % (self.jobsTableName,)\n conn.cursor.execute(query, [self.STATUS_COMPLETED])\n return"
241 },
242 {
243 "code": "def union(self, i):\n if self.intersects(i) or self.end + 1 == i.start or i.end + 1 == self.start:\n return Interval(min(self.start, i.start), max(self.end, i.end))\n else:\n return None"
244 },
245 {
246 "code": "def clear_obj(self, obj):\n obj_nodes = self.get_nodes_with(obj)\n removed = set()\n for node in obj_nodes:\n if self.has_node(node):\n removed.update(self.clear_descendants(node))\n return removed"
247 },
248 {
249 "code": "def terminate(self):\n if self._pool is not None:\n self._pool.terminate()\n self._pool.join()\n self._pool = None"
250 },
251 {
252 "code": "def tex_parse(string):\n\tstring = string.replace('{', '').replace('}', '')\n\tdef tex_replace(match):\n\t\treturn \\\n\t\t\tsub(r'\\^(\\w)', r'<sup>\\1</sup>',\n\t\t\tsub(r'\\^\\{(.*?)\\}', r'<sup>\\1</sup>',\n\t\t\tsub(r'\\_(\\w)', r'<sub>\\1</sub>',\n\t\t\tsub(r'\\_\\{(.*?)\\}', r'<sub>\\1</sub>',\n\t\t\tsub(r'\\\\(' + GREEK_LETTERS + ')', r'&\\1;', match.group(1))))))\n\treturn mark_safe(sub(r'\\$([^\\$]*)\\$', tex_replace, escape(string)))"
253 },
254 {
255 "code": "def create_tar(tar_filename, files, config_dir, config_files):\n with contextlib.closing(tarfile.open(tar_filename, 'w:gz', dereference=True)) as tar:\n for filename in files:\n if os.path.isfile(filename):\n tar.add(filename, arcname=os.path.basename(filename))\n else:\n raise Exception(\"%s is not an existing file\" % filename)\n if os.path.isdir(config_dir):\n tar.add(config_dir, arcname=get_heron_sandbox_conf_dir())\n else:\n raise Exception(\"%s is not an existing directory\" % config_dir)\n for filename in config_files:\n if os.path.isfile(filename):\n arcfile = os.path.join(get_heron_sandbox_conf_dir(), os.path.basename(filename))\n tar.add(filename, arcname=arcfile)\n else:\n raise Exception(\"%s is not an existing file\" % filename)"
256 },
257 {
258 "code": "def _load(self, config):\n if isinstance(config, six.string_types):\n try:\n config = json.loads(config)\n except ValueError:\n pass\n if not isinstance(config, dict):\n raise TypeError('config block must be an istance '\n 'of dict or a valid NetJSON string')\n return config"
259 },
260 {
261 "code": "def start(self):\n self.__thread = Thread(target=self.__run, args=(True, False))\n self.__thread.setDaemon(True)\n self.__thread.start()"
262 },
263 {
264 "code": "def parse_log_messages(self, text):\n regex = r\"commit ([0-9a-f]+)\\nAuthor: (.*?)\\n\\n(.*?)(?:\\n\\n|$)\"\n messages = re.findall(regex, text, re.DOTALL)\n parsed = []\n for commit, author, message in messages:\n parsed.append((\n commit[:10],\n re.sub(r\"\\s*<.*?>\", \"\", author),\n message.strip()\n ))\n return parsed"
265 },
266 {
267 "code": "def shuffle_cols(seqarr, newarr, cols):\n for idx in xrange(cols.shape[0]):\n newarr[:, idx] = seqarr[:, cols[idx]]\n return newarr"
268 },
269 {
270 "code": "def variables(self):\n for table in self.tables:\n if isinstance(table, VariableTable):\n for statement in table.rows:\n if statement[0] != \"\":\n yield statement"
271 },
272 {
273 "code": "def empty_like(array, dtype=None):\n array = numpy.asarray(array)\n if dtype is None: \n dtype = array.dtype\n return anonymousmemmap(array.shape, dtype)"
274 },
275 {
276 "code": "def handle(self):\n while True:\n try:\n line = self.rfile.readline()\n try:\n cmd = json.loads(line)\n except Exception, exc:\n self.wfile.write(repr(exc) + NEWLINE)\n continue\n else:\n handler = getattr(self, 'handle_' + cmd[0], None)\n if not handler:\n self.wfile.write(\n repr(CommandNotFound(cmd[0])) + NEWLINE)\n continue\n return_value = handler(*cmd[1:])\n if not return_value:\n continue\n self.wfile.write(\n one_lineify(json.dumps(return_value)) + NEWLINE)\n except Exception, exc:\n self.wfile.write(repr(exc) + NEWLINE)\n continue"
277 },
278 {
279 "code": "def build_index_and_mapping(triples):\n ents = bidict()\n rels = bidict()\n ent_id = 0\n rel_id = 0\n collected = []\n for t in triples:\n for e in (t.head, t.tail):\n if e not in ents:\n ents[e] = ent_id\n ent_id += 1\n if t.relation not in rels:\n rels[t.relation] = rel_id\n rel_id += 1\n collected.append(kgedata.TripleIndex(ents[t.head], rels[t.relation], ents[t.tail]))\n return collected, ents, rels"
280 },
281 {
282 "code": "def file(self, item, **kwargs):\n query_string = \"/{t}/{u}/items/{i}/file\".format(\n u=self.library_id, t=self.library_type, i=item.upper()\n )\n return self._build_query(query_string, no_params=True)"
283 },
284 {
285 "code": "def prohibit(self, data):\n for char in data:\n for lookup in self.prohibited:\n if lookup(char):\n raise StringprepError(\"Prohibited character: {0!r}\"\n .format(char))\n return data"
286 },
287 {
288 "code": "def _read_header(self, data):\n version = self._read_version(data)\n version_info = self._get_version_info(version)\n header_data = data[:version_info['header_size']]\n header = version_info['header']\n header = header._make(\n unpack(version_info['header_format'], header_data))\n header = dict(header._asdict())\n flags = list(\"{0:0>8b}\".format(header['flags']))\n flags = dict(version_info['flags']._make(flags)._asdict())\n flags = dict((i, bool(int(j))) for i, j in flags.iteritems())\n header['flags'] = flags\n timestamp = None\n if flags['timestamp']:\n ts_start = version_info['header_size']\n ts_end = ts_start + version_info['timestamp_size']\n timestamp_data = data[ts_start:ts_end]\n timestamp = unpack(\n version_info['timestamp_format'], timestamp_data)[0]\n header['info'] = {'timestamp': timestamp}\n return header"
289 },
290 {
291 "code": "def fill_dups_arr(data):\n duplefiles = glob.glob(os.path.join(data.tmpdir, \"duples_*.tmp.npy\"))\n duplefiles.sort(key=lambda x: int(x.rsplit(\"_\", 1)[-1][:-8]))\n io5 = h5py.File(data.clust_database, 'r+')\n dfilter = io5[\"duplicates\"]\n init = 0\n for dupf in duplefiles:\n end = int(dupf.rsplit(\"_\", 1)[-1][:-8])\n inarr = np.load(dupf)\n dfilter[init:end] = inarr\n init += end-init\n LOGGER.info(\"all duplicates: %s\", dfilter[:].sum())\n io5.close()"
292 },
293 {
294 "code": "def _pop(self, model):\n tags = []\n for tag in model.tags:\n if self.is_tag(tag):\n tags.append(tag)\n if tags:\n for tag in tags:\n model.tags.remove(tag)\n return tags"
295 },
296 {
297 "code": "def lookup_api_key_info():\n info = {}\n with db_connect() as conn:\n with conn.cursor() as cursor:\n cursor.execute(ALL_KEY_INFO_SQL_STMT)\n for row in cursor.fetchall():\n id, key, name, groups = row\n user_id = \"api_key:{}\".format(id)\n info[key] = dict(id=id, user_id=user_id,\n name=name, groups=groups)\n return info"
298 },
299 {
300 "code": "def _get_base_component(self):\n comp = topology_pb2.Component()\n comp.name = self.name\n comp.spec = topology_pb2.ComponentObjectSpec.Value(\"PYTHON_CLASS_NAME\")\n comp.class_name = self.python_class_path\n comp.config.CopyFrom(self._get_comp_config())\n return comp"
301 }
302]