File size: 43,187 Bytes
392470d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 |
[
{
"code": "def _publish_instruction_as_executed(self, insn):\n self._icount += 1\n self._publish('did_execute_instruction', self._last_pc, self.PC, insn)"
},
{
"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)"
},
{
"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"
},
{
"code": "def _generate_index(self):\n self._dict = {v.id: k for k, v in enumerate(self)}"
},
{
"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"
},
{
"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 )"
},
{
"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"
},
{
"code": "def angle(x0, y0, x1, y1):\r\n return degrees(atan2(y1-y0, x1-x0))"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"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\")"
},
{
"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)"
},
{
"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)"
},
{
"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))"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"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}"
},
{
"code": "def filter_dict(unfiltered, filter_keys):\n filtered = DotDict()\n for k in filter_keys:\n filtered[k] = unfiltered[k]\n return filtered"
},
{
"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)"
},
{
"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)"
},
{
"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()"
},
{
"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"
},
{
"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"
},
{
"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)"
},
{
"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)"
},
{
"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()"
},
{
"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 )"
},
{
"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)"
},
{
"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 ''"
},
{
"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"
},
{
"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)"
},
{
"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')"
},
{
"code": "def commit(self, *args, **kwargs):\n return super(Deposit, self).commit(*args, **kwargs)"
},
{
"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"
},
{
"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)"
},
{
"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 })"
},
{
"code": "def addInstance(self, groundTruth, prediction, record = None, result = None):\n self.value = self.avg(prediction)"
},
{
"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"
},
{
"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:]"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"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()"
},
{
"code": "def _getEphemeralMembers(self):\n e = BacktrackingTM._getEphemeralMembers(self)\n if self.makeCells4Ephemeral:\n e.extend(['cells4'])\n return e"
},
{
"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))"
},
{
"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)"
},
{
"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"
},
{
"code": "def end(self):\n return Range(self.source_buffer, self.end_pos, self.end_pos,\n expanded_from=self.expanded_from)"
},
{
"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"
},
{
"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']"
},
{
"code": "def _httplib2_init(username, password):\n obj = httplib2.Http()\n if username and password:\n obj.add_credentials(username, password)\n return obj"
},
{
"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)"
},
{
"code": "def settings(self):\n for table in self.tables:\n if isinstance(table, SettingTable):\n for statement in table.statements:\n yield statement"
},
{
"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)"
},
{
"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())"
},
{
"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"
},
{
"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)"
},
{
"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 )"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"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)"
},
{
"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"
},
{
"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()"
},
{
"code": "def _validate_ram(ram_in_mb):\n return int(GoogleV2CustomMachine._MEMORY_MULTIPLE * math.ceil(\n ram_in_mb / GoogleV2CustomMachine._MEMORY_MULTIPLE))"
},
{
"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"
},
{
"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"
},
{
"code": "def _f_gene(sid, prefix=\"G_\"):\n sid = sid.replace(SBML_DOT, \".\")\n return _clip(sid, prefix)"
},
{
"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))"
},
{
"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"
},
{
"code": "def pickle_save(thing,fname):\n pickle.dump(thing, open(fname,\"wb\"),pickle.HIGHEST_PROTOCOL)\n return thing"
},
{
"code": "def utime(self, *args, **kwargs):\n os.utime(self.extended_path, *args, **kwargs)"
},
{
"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)"
},
{
"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)"
},
{
"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"
},
{
"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]))"
},
{
"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"
},
{
"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"
},
{
"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"
},
{
"code": "def terminate(self):\n if self._pool is not None:\n self._pool.terminate()\n self._pool.join()\n self._pool = None"
},
{
"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)))"
},
{
"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)"
},
{
"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"
},
{
"code": "def start(self):\n self.__thread = Thread(target=self.__run, args=(True, False))\n self.__thread.setDaemon(True)\n self.__thread.start()"
},
{
"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"
},
{
"code": "def shuffle_cols(seqarr, newarr, cols):\n for idx in xrange(cols.shape[0]):\n newarr[:, idx] = seqarr[:, cols[idx]]\n return newarr"
},
{
"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"
},
{
"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)"
},
{
"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"
},
{
"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"
},
{
"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)"
},
{
"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"
},
{
"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"
},
{
"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()"
},
{
"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"
},
{
"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"
},
{
"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"
}
] |