text
stringlengths
67
7.88k
<|fim_prefix|>def <|fim_suffix|>(self): # Test example from page 4 of # https://www.haystack.mit.edu/tech/vlbi/mark5/docs/230.3.pdf stream_hex = '0000 002D 0330 0000' + 'FFFF FFFF' + '4053 2143 3805 5' self.crc_hex = '284' self.crc12 = CRC(0x180f) self.crcstack12 = CRCStack(0x180f) self.stream_hex = stream_hex.replace(' ', '').lower() self.stream = int(self.stream_hex, base=16) self.bitstream = self.hex_to_stream(self.stream_hex) self.crc = int(self.crc_hex, base=16) self.crcstream = self.hex_to_stream(self.crc_hex)<|fim_middle|>setup_class<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(tokenizer, train_batch_size, eval_batch_size): # Load dataset train_dataset, test_dataset = load_dataset("imdb", split=["train", "test"]) # Preprocess train dataset train_dataset = train_dataset.map( lambda e: tokenizer(e["text"], truncation=True, padding="max_length"), batched=True ) train_dataset.set_format(type="tensorflow", columns=["input_ids", "attention_mask", "label"]) train_features = { x: train_dataset[x].to_tensor(default_value=0, shape=[None, tokenizer.model_max_length]) for x in ["input_ids", "attention_mask"] } tf_train_dataset = tf.data.Dataset.from_tensor_slices((train_features, train_dataset["label"])) # Preprocess test dataset test_dataset = test_dataset.map( lambda e: tokenizer(e["text"], truncation=True, padding="max_length"), batched=True ) test_dataset.set_format(type="tensorflow", columns=["input_ids", "attention_mask", "label"]) test_features = { x: test_dataset[x].to_tensor(default_value=0, shape=[None, tokenizer.model_max_length]) for x in ["input_ids", "attention_mask"] } tf_test_dataset = tf.data.Dataset.from_tensor_slices((test_features, test_dataset["label"])) if SDP_ENABLED: tf_train_dataset = tf_train_dataset.shard(sdp.size(), sdp.rank()) tf_test_dataset = tf_test_dataset.shard(sdp.size(), sdp.rank()) tf_train_dataset = tf_train_dataset.batch(train_batch_size, drop_remainder=True) tf_test_dataset = tf_test_dataset.batch(eval_batch_size, drop_remainder=True) return tf_train_dataset, tf_test_dataset<|fim_middle|>get_datasets<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return self.METHOD_NAME<|fim_middle|>auto_decompress<|file_separator|>
<|fim_prefix|>async def <|fim_suffix|>(data, objectService): """We can upload a small amount of literal data""" name = f"taskcluster/test/client-py/{taskcluster.slugid.v4()}" await upload.uploadFromBuf( projectId="taskcluster", name=name, contentType="text/plain", contentLength=len(data), expires=taskcluster.fromNow('1 hour'), data=data, objectService=objectService) got, contentType = await download.downloadToBuf( name=name, objectService=objectService) assert got == data assert contentType == 'text/plain'<|fim_middle|>do_over_wire_buf_test<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, name): return self.has_callback(name) and self.num_callbacks(name) > 0<|fim_middle|>will_callback<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(y: Float64Array, x: Float64Array) -> Float64Array: """ Projection of y on x from y Parameters ---------- y : ndarray Array to project (nobs by nseries) x : ndarray Array to project onto (nobs by nvar) Returns ------- ndarray Projected values of y (nobs by nseries) """ if x.shape[1] == 0: return np.zeros_like(y) return x @ (np.linalg.pinv(x) @ y)<|fim_middle|>proj<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(current_actor_context): """ Report if there's configuration for a type we don't recognize. """ current_actor_context.feed(IfCfg( filename="/NM/ifcfg-pigeon0", properties=(IfCfgProperty(name="TYPE", value="AvianCarrier"),) )) current_actor_context.feed(INITSCRIPTS_AND_NM_INSTALLED) current_actor_context.run() assert len(current_actor_context.consume(Report)) == 1 report_fields = current_actor_context.consume(Report)[0].report assert is_inhibitor(report_fields) assert "unsupported device types" in report_fields['title']<|fim_middle|>test_ifcfg_unknown_type<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """test label formatter for histogram for None""" formatted_label = self.histogram._format_bin_labels(None) assert formatted_label == "null and up"<|fim_middle|>test_histogram_label_formatter_none<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return all( self.datasets[key].METHOD_NAME for key in self.datasets )<|fim_middle|>supports_fetch_outside_dataloader<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>() -> None: """ Main function """ # Dir path if len(sys.argv) != 2: sys.stderr.write(f'Usage: {sys.argv[0]} <setup_dir>\n') exit(2) dirpath = sys.argv[1] # Dir non existence if os.path.exists(dirpath): sys.stderr.write(f'Directory: {dirpath} already exists.\n') exit(1) generate_setup_dir(dirpath)<|fim_middle|>main<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(scene): img = ImageMobject( np.uint8([[63, 0, 0, 0], [0, 127, 0, 0], [0, 0, 191, 0], [0, 0, 0, 255]]), ) img.height = 2 img1 = img.copy() img2 = img.copy() img3 = img.copy() img4 = img.copy() img5 = img.copy() img1.set_resampling_algorithm(RESAMPLING_ALGORITHMS["nearest"]) img2.set_resampling_algorithm(RESAMPLING_ALGORITHMS["lanczos"]) img3.set_resampling_algorithm(RESAMPLING_ALGORITHMS["linear"]) img4.set_resampling_algorithm(RESAMPLING_ALGORITHMS["cubic"]) img5.set_resampling_algorithm(RESAMPLING_ALGORITHMS["box"]) scene.add(img1, img2, img3, img4, img5) [s.shift(4 * LEFT + pos * 2 * RIGHT) for pos, s in enumerate(scene.mobjects)] scene.wait()<|fim_middle|>test_image_interpolation<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(devName): devName = resolveDevName(devName) return os.path.exists(os.path.join("/sys/devices/virtual/block/", devName))<|fim_middle|>is_virtual_device<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(elec_txt_dataframe): """Parse keys from EIA series_id string.""" input_ = elec_txt_dataframe.iloc[[2], :] expected = pd.DataFrame( { "series_code": ["RECEIPTS_BTU"], "fuel_agg": ["NG"], "geo_agg": ["US"], "sector_agg": ["2"], "temporal_agg": ["Q"], }, index=[2], ) actual = bulk._extract_keys_from_series_id(input_) pd.testing.assert_frame_equal(actual, expected)<|fim_middle|>test_extract_keys_from_series_id<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, context, data_dict, fields_types, query_dict): '''Modify queries made on datastore_delete The overall design is that every IDatastore extension will receive the ``query_dict`` with the modifications made by previous extensions, then it can add/remove stuff into it before passing it on. You can think of it as pipes, where the ``query_dict`` is being passed to each IDatastore extension in the order they've been loaded allowing them to change the ``query_dict``. The ``datastore`` extension always comes first. The ``query_dict`` is on the form: { 'where': [] } As extensions can both add and remove those keys, it's not guaranteed that any of them will exist when you receive the ``query_dict``, so you're supposed to test the existence of any keys before modifying them. The ``where`` elements are on the form: (format_string, param1, param2, ...) The ``format_string`` isn't escaped for SQL Injection attacks, so everything coming from the user should be in the params list. With this format, you could do something like: ('"age" BETWEEN %s AND %s', age_between[0], age_between[1]) This escapes the ``age_between[0]`` and ``age_between[1]`` making sure we're not vulnerable. After finishing this, you should return your modified ``query_dict``. :param context: the context :type context: dictionary :param data_dict: the parameters received from the user :type data_dict: dictionary :param fields_types: the current resource's fields as dict keys and their types as values :type fields_types: dictionary :param query_dict: the current query_dict, as changed by the IDatastore extensions that ran before yours :type query_dict: dictionary :returns: the query_dict with your modifications :rtype: dictionary ''' return query_dict<|fim_middle|>datastore_delete<|file_separator|>
<|fim_prefix|>f <|fim_suffix|>(self):<|fim_middle|>test_counter<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(plugins: list[dict[str, str]]) -> list[dict[str, str]]: plugins_dict: dict[str, dict[str, str]] = {} for plugin in plugins: # Plugins from later indexes override others plugin["name"] = plugin["name"].lower() plugins_dict[plugin["name"]] = plugin return sorted(plugins_dict.values(), key=lambda p: p["name"])<|fim_middle|>deduplicate_plugins<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): self.file.METHOD_NAME()<|fim_middle|>close<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(train_data, train_labels, predict_data, nClasses): # Create an algorithm object and call compute train_algo = d4p.bf_knn_classification_training(nClasses=nClasses, fptype="float") train_result = train_algo.METHOD_NAME(train_data, train_labels) # Create an algorithm object and call compute predict_algo = d4p.bf_knn_classification_prediction(nClasses=nClasses, fptype="float") predict_result = predict_algo.METHOD_NAME(predict_data, train_result.model) return predict_result<|fim_middle|>compute<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): request = Mock(method="BADWOLF") view = Mock() obj = Mock() perm_obj = KolibriAuthPermissions() self.assertFalse(perm_obj.has_object_permission(request, view, obj))<|fim_middle|>test_bad_request_method<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, *args, **kwargs): public_doc_records = public_doc_query() for doc in public_doc_records: pdf_name = create_name(doc) # We don't want to delete the original so we are not moving and we can't rename and copy at the same time try: temp_name = grab_doc(pdf_name) add_me = True except ClientError: add_me = False logger.error(f"DOWNLOAD FAILED: {pdf_name}") if add_me is True: url = add_to_public( pdf_name, doc["audit_year"], doc["dbkey"], temp_name ) add_to_model(doc["id"], url)<|fim_middle|>handle<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(bucket, file_name): """ Exposes helper method without breaking existing bindings/dependencies """ return storage_service_key_source_function(bucket, file_name)<|fim_middle|>storage_service_key<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(argv, log=False): """Call nvcc with arguments assembled from argv. Args: argv: A list of strings, possibly the argv passed to main(). log: True if logging is requested. Returns: The return value of calling os.system('nvcc ' + args) """ src_files = [f for f in argv if re.search('\.cpp$|\.cc$|\.c$|\.cxx$|\.C$', f)] if len(src_files) == 0: raise Error('No source files found for cuda compilation.') out_file = [ f for f in argv if f.startswith('/Fo') ] if len(out_file) != 1: raise Error('Please sepecify exactly one output file for cuda compilation.') out = ['-o', out_file[0][len('/Fo'):]] nvcc_compiler_options, argv = GetNvccOptions(argv) opt_option, argv = GetOptionValue(argv, 'O') opt = ['-g', '-G'] if (len(opt_option) > 0 and opt_option[0] != 'd'): opt = ['-O2'] include_options, argv = GetOptionValue(argv, 'I') includes = ["-I " + include for include in include_options] defines, argv = GetOptionValue(argv, 'D') defines = ['-D' + define for define in defines] undefines, argv = GetOptionValue(argv, 'U') undefines = ['-U' + define for define in undefines] # The rest of the unrecongized options should be passed to host compiler host_compiler_options = [option for option in argv if option not in (src_files + out_file)] m_options = ["-m64"] nvccopts = ['-D_FORCE_INLINES'] for capability in supported_cuda_compute_capabilities: capability = capability.replace('.', '') nvccopts += [r'-gencode=arch=compute_%s,"code=sm_%s,compute_%s"' % ( capability, capability, capability)] nvccopts += nvcc_compiler_options nvccopts += undefines nvccopts += defines nvccopts += m_options nvccopts += ['--compiler-options="' + " ".join(host_compiler_options) + '"'] nvccopts += ['-x', 'cu'] + opt + includes + out + ['-c'] + src_files # If we don't specify --keep-dir, nvcc will generate intermediate files under TEMP # Put them under NVCC_TEMP_DIR instead, then Bazel can ignore files under NVCC_TEMP_DIR during dependency check # http://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#options-for-guiding-compiler-driver # Different actions are sharing NVCC_TEMP_DIR, so we cannot remove it if the directory already exists. if os.path.isfile(NVCC_TEMP_DIR): os.remove(NVCC_TEMP_DIR) if not os.path.exists(NVCC_TEMP_DIR): os.makedirs(NVCC_TEMP_DIR) nvccopts += ['--keep', '--keep-dir', NVCC_TEMP_DIR] cmd = [NVCC_PATH] + nvccopts if log: Log(cmd) proc = subprocess.Popen(cmd, stdout=sys.stdout, stderr=sys.stderr, env=os.environ.copy(), shell=True) proc.wait() return proc.returncode<|fim_middle|>invoke_nvcc<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(fmt, *args): s = fmt.format(*args) return (s, len(s))<|fim_middle|>wiki_format_raw<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(list_name, msgid): return "{}/arch/msg/{}/{}".format(settings.MAILING_LIST_ARCHIVE_URL, list_name, hash_list_message_id(list_name, msgid))<|fim_middle|>construct_message_url<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, model): data = model.db.get_unit_operation_parameters("co2_addition") model.fs.unit.load_parameters_from_database() assert model.fs.unit.energy_electric_flow_vol_inlet.fixed assert ( model.fs.unit.energy_electric_flow_vol_inlet.value == data["energy_electric_flow_vol_inlet"]["value"] )<|fim_middle|>test_load_parameters<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, train_conf, vars_conf): new_opt_confs = [] for param_group in self.param_groups: assert ( param_group["contiguous_params"] != True ), "contiguous_params cannot be used in graph" optimizer_conf = train_conf.optimizer_conf.add() lr = ( param_group["initial_lr"] if "initial_lr" in param_group else param_group["lr"] ) l2 = param_group["weight_decay"] initial_accumulator_value = param_group["initial_accumulator_value"] lr_decay = param_group["lr_decay"] epsilon = param_group["eps"] optimizer_conf.base_learning_rate = lr self._generate_lr_scale_for_optim_conf(param_group, optimizer_conf) optimizer_conf.adagrad_conf.initial_accumulator_value = ( initial_accumulator_value ) optimizer_conf.adagrad_conf.lr_decay = lr_decay optimizer_conf.adagrad_conf.epsilon = epsilon self._generate_grad_clip_conf_for_optim_conf(param_group, optimizer_conf) for param in param_group.parameters: vars_conf[param].l2 = l2 if param.requires_grad: optimizer_conf.variable_op_names.append(vars_conf[param].name) new_opt_confs.append(optimizer_conf) return new_opt_confs<|fim_middle|>generate_conf_for_graph<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """Return the precached index of the object. :rtype: int """ # Get the index of the object in its precache table METHOD_NAME = string_tables[self.precache_table][self._path] # Is the object precached? if METHOD_NAME != INVALID_STRING_INDEX: # Return the precache index return METHOD_NAME # If the object was not precached, raise an error raise PrecacheError( '"{0}" was not able to be precached due to the "{1}" table ' 'reaching its limit.'.format(self._path, self.precache_table))<|fim_middle|>index<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, method, device): """Test pershot save density matrix instruction""" backend = self.backend(method=method, device=device) # Stabilizer test circuit circ = QuantumCircuit(1) circ.x(0) circ.reset(0) circ.h(0) circ.sdg(0) # Target statevector target = qi.DensityMatrix(circ) # Add save label = "state" circ.save_density_matrix(label=label, pershot=True) # Run shots = 10 result = backend.run(transpile(circ, backend, optimization_level=0), shots=shots).result() self.assertTrue(result.success) simdata = result.data(0) self.assertIn(label, simdata) value = simdata[label] for state in value: self.assertEqual(qi.DensityMatrix(state), target)<|fim_middle|>test_save_density_matrix_pershot<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, path, mode): path = path.decode(self.encoding) _evil_name(path) return errno_call(self._context, os.METHOD_NAME, path, mode)<|fim_middle|>chmod<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> str: """ Resource Name. """ return pulumi.get(self, "name")<|fim_middle|>name<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return bool(self.__flags & DEF_BOUND)<|fim_middle|>is_local<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(cfg, in_channels): return RetinaNetModule(cfg, in_channels)<|fim_middle|>build_retinanet<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(pip_version=None): # type: (Optional[PipVersionValue]) -> bool pip_ver = pip_version or PipVersion.DEFAULT return pip_ver.version < Version("23.2")<|fim_middle|>supports_legacy_resolver<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self,nb,data=None): tab_num = nb.get_current_page() tab = nb.get_nth_page(tab_num) alloc = tab.get_allocation() x, y, w, h = (alloc.x, alloc.y, alloc.width, alloc.height) pixbuf = self.svg.get_pixbuf_sub(f'#layer{tab_num}').scale_simple(w-10, h-10, GdkPixbuf.InterpType.BILINEAR) im = self.builder.get_object(f'Image{tab_num}') im.set_from_pixbuf(pixbuf) for c in im.get_parent().get_children(): if c.get_has_tooltip(): m = re.findall(r'<!--(\d+),(\d+)-->', c.get_tooltip_markup()) if len(m) > 0: x1 = int(m[0][0]); y1 = int(m[0][1]) c.set_margin_left(max(0, w * x1/1500)) c.set_margin_top(max(0, h * y1/1000))<|fim_middle|>on_expose<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(d: datetime) -> datetime: # There are two types of datetime objects in Python: naive and aware # Assume any dbt snapshot timestamp that is naive is meant to represent UTC if d is None: return d elif is_aware(d): return d else: return d.replace(tzinfo=pytz.UTC)<|fim_middle|>convert_to_aware<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(cql, namespaces, fes_version='1.0'): """transforms Common Query Language (CQL) query into OGC fes1 syntax""" filters = [] tmp_list = [] logical_op = None LOGGER.debug('CQL: %s', cql) if fes_version.startswith('1.0'): element_or = 'ogc:Or' element_and = 'ogc:And' element_filter = 'ogc:Filter' element_propertyname = 'ogc:PropertyName' element_literal = 'ogc:Literal' elif fes_version.startswith('2.0'): element_or = 'fes20:Or' element_and = 'fes20:And' element_filter = 'fes20:Filter' element_propertyname = 'fes20:Literal' if ' or ' in cql: logical_op = etree.Element(util.nspath_eval(element_or, namespaces)) tmp_list = cql.split(' or ') elif ' OR ' in cql: logical_op = etree.Element(util.nspath_eval(element_or, namespaces)) tmp_list = cql.split(' OR ') elif ' and ' in cql: logical_op = etree.Element(util.nspath_eval(element_and, namespaces)) tmp_list = cql.split(' and ') elif ' AND ' in cql: logical_op = etree.Element(util.nspath_eval(element_and, namespaces)) tmp_list = cql.split(' AND ') if tmp_list: LOGGER.debug('Logical operator found (AND/OR)') else: tmp_list.append(cql) for t in tmp_list: filters.append(_parse_condition(t, fes_version)) root = etree.Element(util.nspath_eval(element_filter, namespaces)) if logical_op is not None: root.append(logical_op) for flt in filters: condition = etree.Element(util.nspath_eval(flt[0], namespaces)) etree.SubElement( condition, util.nspath_eval(element_propertyname, namespaces)).text = flt[1] etree.SubElement( condition, util.nspath_eval(element_literal, namespaces)).text = flt[2] if logical_op is not None: logical_op.append(condition) else: root.append(condition) LOGGER.debug('Resulting OGC Filter: %s', etree.tostring(root, pretty_print=1)) return root<|fim_middle|>cql2fes<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(redis, key: str) -> Any: """ Gets a JSON serialized value from the cache. """ cached_value = redis.get(key) if cached_value: logger.debug(f"Redis Cache - hit {key}") try: deserialized = json.loads(cached_value) return deserialized except Exception as e: logger.warning(f"Unable to deserialize json cached response: {e}") # In the case we are unable to deserialize, delete the key so that # it may be properly re-cached. redis.delete(key) return None logger.debug(f"Redis Cache - miss {key}") return None<|fim_middle|>get_json_cached_key<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> None: self.store.METHOD_NAME() try: flask.current_app.config.METHOD_NAME() except RuntimeError: pass<|fim_middle|>clear<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, description, uuids=None, report=None): """Check that the delta description is correct.""" report = report if report is not None else self.report uuids = sorted(uuids or [REPORT_ID, NOTIFICATION_DESTINATION_ID]) self.assertEqual({"uuids": uuids, "email": self.email, "description": description}, report["delta"])<|fim_middle|>assert_delta<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(mocker, cobbler_api): # Arrange mock_builtins_open = mocker.patch("builtins.open", mocker.mock_open()) mock_system = System(cobbler_api) mock_system.name = "test_manager_regen_ethers_system" mock_system.interfaces = {"default": NetworkInterface(cobbler_api)} mock_system.interfaces["default"].dns_name = "host.example.org" mock_system.interfaces["default"].mac_address = "aa:bb:cc:dd:ee:ff" mock_system.interfaces["default"].ip_address = "192.168.1.2" mock_system.interfaces["default"].ipv6_address = "::1" dnsmasq.MANAGER = None test_manager = dnsmasq.get_manager(cobbler_api) test_manager.systems = [mock_system] # Act test_manager.regen_ethers() # Assert mock_builtins_open.assert_called_once_with("/etc/ethers", "w+", encoding="UTF-8") write_handle = mock_builtins_open() write_handle.write.assert_called_once_with("AA:BB:CC:DD:EE:FF\t192.168.1.2\n")<|fim_middle|>test_manager_regen_ethers<|file_separator|>
<|fim_prefix|>async def <|fim_suffix|>(self, key, user=None, is_iter=False): """ Process a dict lookup message """ logging.debug("Looking up {} for {}".format(key, user)) orig_key = key # Priv and shared keys are handled slighlty differently key_type, key = key.decode("utf8").split("/", 1) try: result = await self.dict.get( key, ns=((user.decode("utf8") if user else self.user) if key_type == "priv" else None) ) if type(result) is str: response = result.encode("utf8") elif type(result) is bytes: response = result else: response = json.dumps(result).encode("ascii") return await (self.reply(b"O", orig_key, response) if is_iter else self.reply(b"O", response)) except KeyError: return await self.reply(b"N")<|fim_middle|>process_lookup<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """Check that all foreign keys are created correctly""" # filter questions on survey questions = list(StudentQuestionBase.objects.filter(survey=self.survey)) self.assertTrue(self.grading_q.pk in [q.pk for q in questions]) self.assertTrue(self.slider_q.pk in [q.pk for q in questions]) self.assertTrue(self.grading_ans.question, self.grading_q) self.assertTrue(self.slider_ans.question, self.slider_q) # filter workfields on survey workfields = list(WorkField.objects.filter(survey=self.survey)) self.assertTrue(self.wfield1 in workfields) self.assertTrue(self.wfield2 in workfields) self.assertFalse(self.wfield_no_survey in workfields) # filter workfield answers on student to make sure we get them all work_answers = list(StudentAnswerWorkField.objects.filter(student=self.student)) self.assertTrue(self.wfieldans1 in work_answers) self.assertTrue(self.wfieldans2 in work_answers) self.assertEqual(len(work_answers), 2)<|fim_middle|>test_foregin_keys<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): self.args = [ "command_dummy", "--host", TESTSERVER_URL + "/service?request=GetCapabilities", ] with open(SERVICE_EXCEPTION_FILE, "rb") as fp: capabilities_doc = fp.read() with mock_httpd( TESTSERVER_ADDRESS, [ ( { "path": "/service?request=GetCapabilities&version=1.1.1&service=WMS", "method": "GET", }, {"status": "200", "body": capabilities_doc}, ) ], ): with capture() as (out, err): with pytest.raises(SystemExit): wms_capabilities_command(self.args) error_msg = err.getvalue().rsplit("-" * 80, 1)[1].strip() assert "Not a capabilities document" in error_msg<|fim_middle|>test_service_exception<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): if LXML_PRESENT: self.assertEqual(registry.lookup('html'), LXMLTreeBuilder) self.assertEqual(registry.lookup('xml'), LXMLTreeBuilderForXML) else: self.assertEqual(registry.lookup('xml'), None) if HTML5LIB_PRESENT: self.assertEqual(registry.lookup('html'), HTML5TreeBuilder) else: self.assertEqual(registry.lookup('html'), HTMLParserTreeBuilder)<|fim_middle|>test_lookup_by_markup_type<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(n_fp, order): """ Prepare DOF permutation vector for each possible facet orientation. """ from sfepy.base.base import dict_to_array if n_fp == 2: mtx = make_line_matrix(order) ori_map = ori_line_to_iter fo = order - 1 elif n_fp == 3: mtx = make_triangle_matrix(order) ori_map = ori_triangle_to_iter fo = order - 2 elif n_fp == 4: mtx = make_square_matrix(order) ori_map = {} for key, val in six.iteritems(_quad_ori_groups): ori_map[key] = ori_square_to_iter[val] fo = order - 1 else: raise ValueError('unsupported number of facet points! (%d)' % n_fp) dof_perms = {} for key, itfun in six.iteritems(ori_map): dof_perms[key] = [mtx[ii] for ii in itfun(fo)] dof_perms = dict_to_array(dof_perms) return dof_perms<|fim_middle|>get_facet_dof_permutations<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> List[NamedUser]: ...<|fim_middle|>assignees<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): model = SemanticSegmentation(2) model.eval() model.serve()<|fim_middle|>test_serve<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict())<|fim_middle|>to_str<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, max_norm, aggregate_norm_fn=None): """Clips gradient norm.""" return utils.clip_grad_norm_(self.params, max_norm, aggregate_norm_fn)<|fim_middle|>clip_grad_norm<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(agent_args, technologies, stock): from muse.agents.agent import Agent from muse.agents.factories import create_agent agent_args["share"] = "agent_share_zero" agent = create_agent( agent_type="Retrofit", technologies=technologies, capacity=stock.capacity, search_rules="from_techs->compress", year=2010, **agent_args, ) assert isinstance(agent, Agent) assert len(agent.assets.capacity) == 0 assert "asset" in agent.assets.dims and len(agent.assets.asset) == 0 assert "year" in agent.assets.dims or len(agent.assets.year) > 1 assert "region" not in agent.assets.dims assert "commodity" not in agent.assets.dims<|fim_middle|>test_issue_835_and_842<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, handler: ErrorHandler[object] | None) -> None: ...<|fim_middle|>set_error_handler<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): pass<|fim_middle|>pre_operations<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>( repo, settings, fs=None, prefix: Optional[Tuple[str, ...]] = None, hash_name: Optional[str] = None, **kwargs, ): from dvc.fs import get_cloud_fs if not settings: return None cls, config, fs_path = get_cloud_fs(repo.config, **settings) fs = fs or cls(**config) if prefix: fs_path = fs.path.join(fs_path, *prefix) if hash_name: config["hash_name"] = hash_name return get_odb(fs, fs_path, state=repo.state, **config)<|fim_middle|>get_odb<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): pass<|fim_middle|>pre_operations<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, skip_run=False, executable=None): # start with the run command cmd = [] if skip_run else self.build_run_cmd(executable=executable) # add arguments and insert dummary key value separators which are replaced with "=" later for key, value in self.args: cmd.extend([key, self.arg_sep, value]) cmd = " ".join(quote_cmd([c]) for c in cmd) cmd = cmd.replace(" " + self.arg_sep + " ", "=") return cmd<|fim_middle|>build<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): raise ValueError("this dispatcher is not writable")<|fim_middle|>handle_write_event<|file_separator|>
<|fim_prefix|>f <|fim_suffix|>(self):<|fim_middle|>get_zone<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """Exporter EntryPoint to call.""" return self.get_record_value('entry_point')<|fim_middle|>entry_point<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(scope): if scope == "list": return [None] elif scope in ["create", "import:backup"]: return [ { "owner": {"id": random.randrange(400, 500)}, "assignee": {"id": random.randrange(500, 600)}, "organization": {"id": random.randrange(600, 700)}, "user": {"num_resources": count}, } for count in (0, 1, 3, 10) ] else: return [ { "id": random.randrange(300, 400), "owner": {"id": random.randrange(400, 500)}, "assignee": {"id": random.randrange(500, 600)}, "organization": {"id": random.randrange(600, 700)}, } ]<|fim_middle|>resources<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(input_event, relation, text_encoder, max_e1, max_r, force): abort = False e1_tokens, rel_tokens, _ = data.conceptnet_data.do_example(text_encoder, input_event, relation, None) if len(e1_tokens) > max_e1: if force: XMB = torch.zeros(1, len(e1_tokens) + max_r).long().to(settings.device) else: XMB = torch.zeros(1, max_e1 + max_r).long().to(settings.device) return {}, True else: XMB = torch.zeros(1, max_e1 + max_r).long().to(settings.device) XMB[:, : len(e1_tokens)] = torch.LongTensor(e1_tokens) XMB[:, max_e1 : max_e1 + len(rel_tokens)] = torch.LongTensor(rel_tokens) batch = {} batch["sequences"] = XMB batch["attention_mask"] = data.conceptnet_data.make_attention_mask(XMB) return batch, abort<|fim_middle|>set_conceptnet_inputs<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return self.maxsize > 0 and len(self.queue) == self.maxsize<|fim_middle|>full<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, item, identity_field=None): identity = {} from_ = item if isinstance(item, dict) and 'data' in item: from_ = item['data']['message'][identity_field] identity['username'] = from_.get('username', None) identity['email'] = None identity['name'] = from_.get('first_name', None) return identity<|fim_middle|>get_sh_identity<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return self.client.format_url( "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}", **self.url_parameters )<|fim_middle|>url<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(test_file): with Image.open(test_file) as im: assert im.tell() == 0 # prior to first image raises an error, both blatant and borderline with pytest.raises(EOFError): im.seek(-1) with pytest.raises(EOFError): im.seek(-523) # after the final image raises an error, # both blatant and borderline with pytest.raises(EOFError): im.seek(2) with pytest.raises(EOFError): im.seek(523) # bad calls shouldn't change the frame assert im.tell() == 0 # this one will work im.seek(1) assert im.tell() == 1 # and this one, too im.seek(0) assert im.tell() == 0<|fim_middle|>test_seek<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): """See base_runner.""" return True<|fim_middle|>has_heartbeat<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(configuration_policy_group_name: Optional[pulumi.Input[str]] = None, resource_group_name: Optional[pulumi.Input[str]] = None, vpn_server_configuration_name: Optional[pulumi.Input[str]] = None, opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetConfigurationPolicyGroupResult]: """ Retrieves the details of a ConfigurationPolicyGroup. :param str configuration_policy_group_name: The name of the ConfigurationPolicyGroup being retrieved. :param str resource_group_name: The resource group name of the VpnServerConfiguration. :param str vpn_server_configuration_name: The name of the VpnServerConfiguration. """ ...<|fim_middle|>get_configuration_policy_group_output<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(wn, tn): if tn is None: # special case. i.e. the last tile. #dont know why it is a special case, if the ALL-1 is received with a tile #then it should always be one, if the tile is consired received by the method #below, then it should not be false #i think the problem is when the sender does not know if it is the last one #so the the bitmap is received with the max_fcn bit on 1, but since there are #less tiles than the max_fcn. it does not look for that bit dprint("last tile case") #self.all_tiles[-1]["sent"] = False return # normal case. counter = 0 dprint('unset_sent_flag_do') for t in self.all_tiles: if t["w-num"] == wn: if t["t-num"] == self.max_fcn - tn: counter += 1 dprint('counter = {}, t-num {}, tn {}'.format(counter, t["t-num"],tn)) t["sent"] = False elif t["t-num"] == self.max_fcn: dprint("t-num {} == max_fcn {}".format(t["t-num"],self.max_fcn))<|fim_middle|>unset_sent_flag_do<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>( self, painter: QtGui.QPainter, option: QtWidgets.QStyleOptionGraphicsItem, # pylint: disable=unused-argument widget: Optional[QtWidgets.QWidget] = ..., ): # pylint: disable=unused-argument self._paint_boundary(painter)<|fim_middle|>paint<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """Configure the DUT (Router in our case) which we use for testing the EMU functionality prior to the test""" sys.stdout.flush() if not CTRexScenario.router_cfg['no_dut_config']: sys.stdout.write('Configuring DUT... ') start_time = time.time() CTRexScenario.router.load_clean_config() CTRexScenario.router.configure_basic_interfaces() sys.stdout.write('Done. (%ss)\n' % int(time.time() - start_time))<|fim_middle|>config_dut<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, peer_id: ID) -> PublicKey: """ :param peer_id: peer ID to get public key for :return: public key of the peer :raise PeerStoreError: if peer ID not found """<|fim_middle|>pubkey<|file_separator|>
<|fim_prefix|>f <|fim_suffix|>(self, flag):<|fim_middle|>set_wires<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, get_ipython, clear_output): """ Context manager that monkeypatches get_ipython and clear_output """ original_clear_output = widget_output.clear_output original_get_ipython = widget_output.get_ipython widget_output.get_ipython = get_ipython widget_output.clear_output = clear_output try: yield finally: widget_output.clear_output = original_clear_output widget_output.get_ipython = original_get_ipython<|fim_middle|>mocked_ipython<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): with pytest.raises(ImportError): from ddtrace.constants import INVALID_CONSTANT # noqa<|fim_middle|>test_invalid<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(lnst_config): for preset_name in PRESETS: preset = lnst_config.get_option("colours", preset_name) if preset == None: continue fg, bg, bf = preset extended_re = "^extended\([0-9]+\)$" if fg == "default": fg = None elif not re.match(extended_re, fg) and fg not in list(COLOURS.keys()): raise Exception("Colour '%s' not supported" % fg) if bg == "default": bg = None elif not re.match(extended_re, bg) and bg not in list(COLOURS.keys()): raise Exception("Colour '%s' not supported" % bg) PRESETS[preset_name] = [fg, bg, bool_it(bf)]<|fim_middle|>load_presets_from_config<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> LoggingMode: """ Get the logger's mode. :return: The logger mode. """ return self._mode<|fim_middle|>mode<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(data): """ Calculates the CRC32C checksum of the provided data. Args: data: the bytes over which the checksum should be calculated. Returns: An int representing the CRC32C checksum of the provided bytes. """ return _crc32c(six.ensure_binary(data))<|fim_middle|>crc32c<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, model): pass # Not needed<|fim_middle|>add_type<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): size = 100 matrix = torch.randn(size, size, dtype=torch.float64) matrix = matrix.matmul(matrix.mT) matrix.div_(matrix.norm()) matrix.add_(torch.eye(matrix.size(-1), dtype=torch.float64).mul_(1e-1)) # set up vector rhs rhs = torch.randn(size, dtype=torch.float64) # basic solve solves = linear_cg(matrix.matmul, rhs=rhs, max_iter=size) # solve with init value init = torch.randn(size, dtype=torch.float64) solves_with_init = linear_cg(matrix.matmul, rhs=rhs, max_iter=size, initial_guess=init) # Check cg matrix_chol = torch.linalg.cholesky(matrix) actual = torch.cholesky_solve(rhs.unsqueeze(dim=1), matrix_chol).squeeze() self.assertTrue(torch.allclose(solves, actual, atol=1e-3, rtol=1e-4)) self.assertTrue(torch.allclose(solves_with_init, actual, atol=1e-3, rtol=1e-4)) # set up matrix rhs numcols = 50 rhs = torch.randn(size, numcols, dtype=torch.float64) # basic solve solves = linear_cg(matrix.matmul, rhs=rhs, max_iter=size) # solve with init value init = torch.randn(size, numcols, dtype=torch.float64) solves_with_init = linear_cg(matrix.matmul, rhs=rhs, max_iter=size, initial_guess=init) # Check cg actual = torch.cholesky_solve(rhs, matrix_chol) self.assertTrue(torch.allclose(solves, actual, atol=1e-3, rtol=1e-4)) self.assertTrue(torch.allclose(solves_with_init, actual, atol=1e-3, rtol=1e-4))<|fim_middle|>test_cg<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): if Promise.unhandled_exceptions: for exctype, value, tb in Promise.unhandled_exceptions: if value: raise value.with_traceback(tb) # traceback.print_exception(exctype, value, tb)<|fim_middle|>rereaise_unhandled<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(src_lines, var_name, lines): add_comments_header(lines) lines.append("const char *{0} =".format(var_name)) for src_line in src_lines: lines.append('"' + cpp_escape(src_line) + "\\n\"") lines[len(lines) - 1] += ';' add_comments_footer(lines)<|fim_middle|>add_cpp_string_literal<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return os.path.join(self.save_path, 'train')<|fim_middle|>train_path<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): mc = MailChimp(mc_api=app.config["MAILCHIMP_KEY"]) try: email = request.form.get("email") try: data = mc.lists.members.create_or_update( list_id=app.config["MAILCHIMP_LIST"], subscriber_hash=get_subscriber_hash(email), data={ "email_address": email, "status": "subscribed", "status_if_new": "pending", }, ) status = data.get("status") if status == "pending": flash( "Thanks for subscribing! You will receive a confirmation email shortly." ) elif status == "subscribed": flash("You were already subscribed! Thanks for checking back.") else: raise ValueError("Unexpected status %s" % status) except ValueError as e: # ugh, this library is awful app.logger.info( "ValueError from mailchimp3 %s, assuming bad email: %r", e, email ) flash("Your email address was not accepted - please check and try again.") except MailChimpError as e: # Either the JSON, or a dictionary containing the response (data,) = e.args if data.get("status") != 400: raise title = data.get("title") if title == "Member In Compliance State": app.logger.info("Member in compliance state: %r", email) flash( """You've already been unsubscribed from our list, so we can't add you again. Please contact %s to update your settings.""" % app.config["TICKETS_EMAIL"][1] ) elif title == "Invalid Resource": app.logger.warn( "Invalid Resource from MailChimp, likely bad email or rate limited: %r", email, ) flash( """Your email address was not accepted - please check and try again. If you've signed up to other lists recently, please wait 48 hours.""" ) else: app.logger.warn("MailChimp returned %s: %s", title, data.get("detail")) flash("Sorry, an error occurred: %s." % (title or "unknown")) except Exception as e: app.logger.exception("Error subscribing: %r", e) flash("Sorry, an error occurred.") return redirect(url_for(".main"))<|fim_middle|>main_post<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(): vip = utils.config_get('vip') vip_iface = utils.config_get('vip_iface') vip_cidr = utils.config_get('vip_cidr') corosync_bindiface = utils.config_get('ha-bindiface') corosync_mcastport = utils.config_get('ha-mcastport') if None in [vip, vip_cidr, vip_iface]: utils.juju_log('WARNING', 'Insufficient VIP information to configure cluster') sys.exit(1) # Starting configuring resources. init_services = {'res_mysqld': 'mysql'} # If the 'ha' relation has been made *before* the 'ceph' relation, # it doesn't make sense to make it until after the 'ceph' relation is made if not utils.is_relation_made('ceph', 'auth'): utils.juju_log('INFO', '*ceph* relation does not exist. ' 'Not sending *ha* relation data yet') return else: utils.juju_log('INFO', '*ceph* relation exists. Sending *ha* relation data') block_storage = 'ceph' if utils.config_get('prefer-ipv6'): res_mysql_vip = 'ocf:heartbeat:IPv6addr' vip_params = 'ipv6addr' vip_cidr = '64' else: res_mysql_vip = 'ocf:heartbeat:IPaddr2' vip_params = 'ip' resources = { 'res_mysql_rbd': 'ocf:ceph:rbd', 'res_mysql_fs': 'ocf:heartbeat:Filesystem', 'res_mysql_vip': res_mysql_vip, 'res_mysqld': 'upstart:mysql'} rbd_name = utils.config_get('rbd-name') resource_params = { 'res_mysql_rbd': 'params name="%s" pool="%s" user="%s" ' 'secret="%s"' % (rbd_name, POOL_NAME, SERVICE_NAME, ceph.keyfile_path(SERVICE_NAME)), 'res_mysql_fs': 'params device="/dev/rbd/%s/%s" directory="%s" ' 'fstype="ext4" op start start-delay="10s"' % (POOL_NAME, rbd_name, DATA_SRC_DST), 'res_mysql_vip': 'params "%s"="%s" cidr_netmask="%s" nic="%s"' % (vip_params, vip, vip_cidr, vip_iface), 'res_mysqld': 'op start start-delay="5s" op monitor interval="5s"'} groups = { 'grp_mysql': 'res_mysql_rbd res_mysql_fs res_mysql_vip res_mysqld'} for rel_id in utils.relation_ids('ha'): utils.relation_set(rid=rel_id, block_storage=block_storage, corosync_bindiface=corosync_bindiface, corosync_mcastport=corosync_mcastport, resources=resources, resource_params=resource_params, init_services=init_services, groups=groups)<|fim_middle|>ha_relation_joined<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>( query: str, offset: int, length: int, expected_result: Any, expected_num_rows_total: int ) -> None: # simulate index file index_file_location = "index.duckdb" con = duckdb.connect(index_file_location) con.execute("INSTALL 'httpfs';") con.execute("LOAD 'httpfs';") con.execute("INSTALL 'fts';") con.execute("LOAD 'fts';") con.sql("CREATE OR REPLACE SEQUENCE serial START 0 MINVALUE 0;") sample_df = pd.DataFrame( { "text": [ "Grand Moff Tarkin and Lord Vader are interrupted in their discussion by the buzz of the comlink", "There goes another one.", "Vader turns round and round in circles as his ship spins into space.", "We count thirty Rebel ships.", "The wingman spots the pirateship coming at him and warns the Dark Lord", ] }, dtype=pd.StringDtype(storage="python"), ) create_command_sql = "CREATE OR REPLACE TABLE data AS SELECT nextval('serial') AS __hf_index_id, * FROM sample_df" con.sql(create_command_sql) con.execute(query="SELECT COUNT(*) FROM data;").fetchall() assert sample_df.size == con.execute(query="SELECT COUNT(*) FROM data;").fetchall()[0][0] con.sql("PRAGMA create_fts_index('data', '__hf_index_id', '*', overwrite=1);") con.close() # assert search results (num_rows_total, pa_table) = full_text_search(index_file_location, query, offset, length) assert num_rows_total is not None assert pa_table is not None assert num_rows_total == expected_num_rows_total fields = [pa.field("__hf_index_id", pa.int64()), pa.field("text", pa.string())] filtered_df = pd.DataFrame(expected_result) expected_table = pa.Table.from_pandas(filtered_df, schema=pa.schema(fields), preserve_index=False) assert pa_table == expected_table # ensure that database has not been modified con = duckdb.connect(index_file_location) assert sample_df.size == con.execute(query="SELECT COUNT(*) FROM data;").fetchall()[0][0] con.close() os.remove(index_file_location)<|fim_middle|>test_full_text_search<|file_separator|>
<|fim_prefix|>async def <|fim_suffix|>( db: AsyncSession = Depends(get_async_db), form_data: OAuth2PasswordRequestForm = Depends(),<|fim_middle|>login_for_access_token<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(cls): super().METHOD_NAME() cls.sth_related = SomethingRelated.objects.create(name='Rel1') cls.pol_1 = PolymorphicModelTest.objects.create( name='Pol1', sth_related=cls.sth_related ) cls.pol_2 = PolymorphicModelTest.objects.create( name='Pol2', sth_related=cls.sth_related ) cls.pol_3 = PolymorphicModelTest2.objects.create( name='Pol3', another_related=cls.sth_related, )<|fim_middle|>set_up_class<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): return []<|fim_middle|>get_keywords_to_be_excluded<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): factory = RequestFactory() bad_referers = ( "http://otherdomain/bar/", "http://otherdomain/admin/forms/form/", ) for referer in bad_referers: with self.subTest(referer=referer): request = factory.get( "/api/v1/foo", HTTP_REFERER=referer, SCRIPT_NAME="/of" ) self.assertFalse(is_admin_request(request))<|fim_middle|>test_is_admin_request_false_with_subpath<|file_separator|>
<|fim_prefix|> <|fim_suffix|>(self):<|fim_middle|>run<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): 'od.keys() -> list of keys in od' return list(self)<|fim_middle|>keys<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(minion_id, package_name, state_tree): module_contents = """ def get_test_package_name(): return "{}" """.format( package_name ) top_file_contents = """ base: {}: - install-package """.format( minion_id ) install_package_sls_contents = """ state-entry-contém-unicode: pkg.installed: - name: {{ salt.pkgnames.get_test_package_name() }} """ with pytest.helpers.temp_file( "_modules/pkgnames.py", module_contents, state_tree, ), pytest.helpers.temp_file( "top.sls", top_file_contents, state_tree ), pytest.helpers.temp_file( "install-package.sls", install_package_sls_contents, state_tree, ): # Run the test yield<|fim_middle|>populated_state_tree<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(vineyard_client): df = pd.DataFrame({'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8]}) object_id = vineyard_client.put(df) pd.testing.assert_frame_equal(df, vineyard_client.get(object_id))<|fim_middle|>test_pandas_dataframe<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> str: """ Resource type. """ return pulumi.get(self, "type")<|fim_middle|>type<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self): """ Test rectangular transfer of self.d_array1 to self.d_array2 """ # Reference o1 = self.offset1 o2 = self.offset2 T = self.transfer_shape logger.info("""Testing D->D rectangular copy with (N1_y, N1_x) = %s, (N2_y, N2_x) = %s: array2[%d:%d, %d:%d] = array1[%d:%d, %d:%d]""" % ( str(self.shape1), str(self.shape2), o2[0], o2[0] + T[0], o2[1], o2[1] + T[1], o1[0], o1[0] + T[0], o1[1], o1[1] + T[1] ) ) self.array2[o2[0]:o2[0] + T[0], o2[1]:o2[1] + T[1]] = self.array1[o1[0]:o1[0] + T[0], o1[1]:o1[1] + T[1]] kernel_args = ( self.d_array2.data, self.d_array1.data, np.int32(self.shape2[1]), np.int32(self.shape1[1]), np.int32(self.offset2[::-1]), np.int32(self.offset1[::-1]), np.int32(self.transfer_shape[::-1]) ) wg = None ndrange = self.transfer_shape[::-1] self.program.cpy2d(self.queue, ndrange, wg, *kernel_args) res = self.d_array2.get() self.compare(res, self.array2)<|fim_middle|>test_cpy2d<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, view_size): if self.selection_valid(): before_selection = view_size // 2 self.view.start = max(0, self.selection - before_selection) self.view.end = self.view.start self.max_view_size = view_size self._expand_view() else: self.max_view_size = view_size self._reset_view()<|fim_middle|>resize_view<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(event): """ Control-P in vi edit mode on readline is history next, unlike default prompt toolkit. If completer is open this still select previous completion. """ event.current_buffer.auto_up()<|fim_middle|>previous_history_or_previous_completion<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, X, queue=None): y = super()._predict(X, _backend.linear_model.regression, queue) return y<|fim_middle|>predict<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>( record_property, get_host_key, setup_splunk, setup_sc4s, event ): host = get_host_key dt = datetime.datetime.now(datetime.timezone.utc) iso, _, _, _, _, _, epoch = time_operations(dt) # Tune time functions iso = dt.isoformat()[0:23] epoch = epoch[:-3] mt = env.from_string(event + "\n") message = mt.render(mark="<29>1", iso=iso, host=host) sendsingle(message, setup_sc4s[0], setup_sc4s[1][514]) st = env.from_string( 'search _time={{ epoch }} index=epav host="{{ host }}" sourcetype="kaspersky:es"' ) search = st.render(epoch=epoch, host=host) result_count, _ = splunk_single(setup_splunk, search) record_property("host", host) record_property("resultCount", result_count) record_property("message", message) assert result_count == 1<|fim_middle|>test_kaspersky<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self) -> None: warnings.filterwarnings("default", category=DeprecationWarning) warnings.filterwarnings("ignore", category=DeprecationWarning, module="pyscf") warnings.filterwarnings(action="ignore", category=DeprecationWarning, module=".*drivers*") warnings.filterwarnings( action="default", category=DeprecationWarning, module=".*second_q.drivers.*" ) warnings.filterwarnings( action="ignore", category=DeprecationWarning, module=".*transformers*" ) warnings.filterwarnings( action="default", category=DeprecationWarning, module=".*second_q.transformers.*", ) # ignore opflow/gradients/natural_gradient warnings.filterwarnings("ignore", category=RuntimeWarning, module="qiskit") self._started_at = time.time() self._class_location = __file__<|fim_middle|>set_up<|file_separator|>
<|fim_prefix|>def <|fim_suffix|>(self, channel, on): pass<|fim_middle|>channel_on_off<|file_separator|>