CocoRoF/massive_triplet_v3 · Datasets at Hugging Face

anchor stringlengths 2 528	positive stringlengths 4 6k	negative stringlengths 6 6k
자유 여름의 목적은 무엇이었습니까?	자유 여름은 또한 전국 교회 협의회의 지원을 받았으며, 여름 동안 인권을 위한 의료 위원회의 자원봉사자들과 다양한 단체의 변호사들이 미시시피에서 활동했다. 자유 여름의 장기적인 목표는 미시시피의 권력 구조를 변화시키는 것이었다.	자유의 여름은 또한 전국 교회 협의회의 지원을 받았으며, 여름 동안 인권을 위한 의료 위원회의 자원봉사자들과 다양한 단체의 변호사들이 미시시피에서 활동했습니다. 자유의 여름의 장기적인 목표는 미시시피의 권력 구조를 변화시키는 것이었습니다.
End do_enable; called after state changes but before command acknowledged. This method connects to the HVAC server.	async def end_enable(self, id_data: salobj.BaseDdsDataType) -> None: if not self.connected: await self.connect() await super().end_enable(id_data)	def on_enable(self): self.i_err = 0
Function returns a list of creation datetimes for the files in the list of jpg files paths	def get_creation_times(list_of_jpg): list_of_creation_times = [] for jpg in list_of_jpg: try: image = Image.open(jpg) exif = image.getexif() creation_time = exif.get(36867) except: creation_time = None list_of_creation_times.append(creation_time) return list_of_creation_times	def image_timestamp_list(self) -> Dict[str, List[int]]: assert self.image_list is not None assert self._image_list is not None if self._image_timestamp_list is None: self._image_timestamp_list = {} for log in self.log_list: self._image_timestamp_list[log] = {} for camera in CAMERA_LIST: self._image_timestamp_list[log][camera] = [ int(x.split("/")[-1][:-4].split("_")[-1]) for x in self._image_list[log][camera] ] return self._image_timestamp_list[self.current_log]
Add a new snapshot node. It adds an entry in self.snapshotsCached and creates a new Checkbox object	def __addNewSnapshot__(self, snapshotNode): nodeID = snapshotNode.GetID() print("Added new node " + nodeID) name = snapshotNode.GetName() description = snapshotNode.GetSnapshotDescription() ckb = qt.QCheckBox() ckb.checked = True ckb.text = name ckb.toolTip = "%s. Uploaded to Picasa: NO" % description # Add the checkbox to the layout self.currentSnapshotsInnerLayout.addWidget(ckb) # Add a new snapshot node to the cached collection (Name, Description, Uploaded, Widget) self.snapshotsCached[nodeID] = [name, description, False, ckb] # Add an observer in case the node is modified (example: renamed) self.__addModifiedObserver__(snapshotNode) # Remove no items label if visible self.noItemsLabel.hide()	def push_snapshot(self):
Performs a commit A commit of known offsets for read partitions And subscription positions for untouched partitions	async def _do_commit(self): offsets = self._subscriptions.subscription \ .assignment.all_consumed_offsets() offsets.update(self._offsets) if offsets: await self._consumer.commit(offsets)	def _do_update_update(self, data, offset): assert IMutableUploadable.providedBy(data) assert self.is_mutable() # offset == self.get_size() is valid and means that we are # appending data to the file. assert offset <= self.get_size() segsize = self._version[3] # We'll need the segment that the data starts in, regardless of # what we'll do later. start_segment = offset // segsize # We only need the end segment if the data we append does not go # beyond the current end-of-file. end_segment = start_segment if offset + data.get_size() < self.get_size(): end_data = offset + data.get_size() # The last byte we touch is the end_data'th byte, which is actually # byte end_data - 1 because bytes are zero-indexed. end_data -= 1 end_segment = end_data // segsize self._start_segment = start_segment self._end_segment = end_segment # Now ask for the servermap to be updated in MODE_WRITE with # this update range. return self._update_servermap(update_range=(start_segment, end_segment))
Return a pandas dataframe Goes through all the events and tallies up the points of the students.	def parse_sheets(event_attendance, member_list): attendance = pd.DataFrame() #parse_bonus_points(attendance, member_list) attendance["Name:"] = member_list["First Name"].str.strip() + " " + member_list["Last Name"].str.strip() attendance["Total Spark Points:"] = 0 print(attendance) print(member_list) #Go through all events in the folder and check if the person attended. If yes, add points for index, member in attendance.iterrows(): #print(event_attendance) #print(member) name = str(member["Name:"].strip()).lower() valid = student_list.get(name, "NA") #Add a new student to the dictionary of student_list if not already there print(valid) if(valid == 'NA'): print("Added student " + name) student_list[name.lower()] = {'EID' : 0, 'Points' : 0} for event in event_attendance: eventdata = list(event.columns) event_name = eventdata[-1] #print(event_name) points_to_add = event.iat[0, len(eventdata)-1] attendance.at[index, event_name] = 0 #If the person is in the database and at the meeting, sum up each person's spark points and add to their total if check_attendance(member["Name:"].lower(), event): attendance.at[index, event_name] += points_to_add attendance.at[index, "Total Spark Points:"] += points_to_add #parse_shop() return attendance	def frame_info_to_df(obj_info_aggregated, frame_ind, camera_id, date_time): frame_df = pd.DataFrame(obj_info_aggregated, columns=[ 'obj_bounds', 'obj_classification', 'confidence']) frame_df["frame_id"] = frame_ind frame_df["camera_id"] = camera_id frame_df["video_upload_datetime"] = date_time return frame_df
아드레랄이 인간에게 미칠 수 있는 영향은 무엇인가?	아드레랄은 암페타민으로, 주의력 결핍 과다 행동 장애(ADHD)와 같은 장애를 치료하는 데 사용되는 중추 신경계 자극제입니다. 미국에서 일반적으로 사용되고 처방되는 암페타민에는 덱스트로암페타민이 포함되어 있습니다. 아드레랄은 암페타민과 덱스트로암페타민의 조합으로, ADHD와 기면증 치료에 널리 처방되는 의약품입니다. 아드레랄이 탈모를 유발합니까? 그렇다면 어떻게 유발합니까? 일반적으로 암페타민은 인체에서 잘 견디지만 일부 부작용이 있을 수 있습니다. 장기간 사용 및 중독 시 부작용이 훨씬 더 커지며, 여기에는 모발이 가늘어지거나 탈모가 포함됩니다. 탈모는 일반적으로 두피 전반에 걸쳐 퍼져 있으며 특정한 한 지역에만 집중되지 않습니다.	애드레랄에는 인간 성장 호르몬이 포함되어 있습니까? 애드레랄과 인간 성장 호르몬을 함께 복용할 수 있습니까? Treato에서 애드레랄과 인간 성장 호르몬에 대한 5가지 논의 내 북마크
전설, 속, 인어, 대부분, 사람, 존재, 무섭다	전설 속 인어는 대부분 죄 없는 사람을 해치는 무서운 존재이다.	옛날 다과상 차림은 녹차, 무지개떡, 밤다식, 생란, 율란, 조란 등이다.
Retrieves the pixel value from image Will keep requested pixel values within the bounds of the image	def get_pixel(image, x, y): y = yimage['width'] #Necessary to multiply by width for correct indexing in a list if x < 0: x = 0 if y < 0: y = 0 if x > image['width']-1: x = image['width']-1 if y > (image['height']-1)image['width']: y = (image['height']-1)*image['width'] return image['pixels'][x+y]	def get_input(self, idx): img_filename = os.path.join( self.data_dir, self._input_array[idx]) x = Image.open(img_filename).convert('RGB') return x
Loads a specific dataset file from the csv. Split refers to the EMNIST split in the dataset.	def load_split(self, split, stage): if not split in self.splits: print(split, "is not a valid EMNIST split") return if not stage in self.stages: print(stage, "is not a valid stage") return csv_filename = self.data_folder + "/emnist-" + split + "-" + stage + ".csv" print("Loading", csv_filename) data_frame = pd.read_csv(csv_filename, header=None, dtype=np.int8) tensor_x = torch.Tensor(data_frame.iloc[:,1:].values.reshape((-1, 1, 28, 28))).float() # Load the images tensor_y = torch.Tensor(data_frame.iloc[:,0].values).long() # Load the labels return torch.utils.data.TensorDataset(tensor_x, tensor_y)	def load_data(self): data_frame = pd.read_csv(self.URL, encoding='ISO-8859-1') data_frame = data_frame[['cont_africa', 'rugged', 'rgdppc_2000']] data_frame.rgdppc_2000 = np.log(data_frame.rgdppc_2000) data_frame = data_frame[np.isfinite(data_frame.rgdppc_2000)] datasets = [] for flag in [0, 1]: split = data_frame[data_frame.cont_africa == flag] x, y = split.rugged.to_numpy(), split.rgdppc_2000.to_numpy() datasets.append([x, y]) return datasets
Create a new variable in the model, annotated with the given term, and in the given units.	def _create_annotated_variable(self, prefixed_name, units): #1903 TODO: Be more careful to create unique local names and ids prefix, local_name = prefixed_name.split(':') var = self.add_variable(self._get_protocol_component(), local_name, units, id=prefix + '_' + local_name) var.add_rdf_annotation(('bqbiol:is', NSS['bqbiol']), (prefixed_name, self._protocol_namespaces[prefix])) return var	def add_term(self, term, cursor=None, loci_cursor=None): if not cursor: cur = self.m80.db.cursor() cur.execute("BEGIN TRANSACTION") else: cur = cursor if not loci_cursor: lcur = self.loci.m80.db.cursor() lcur.execute("BEGIN TRANSACTION") else: lcur = loci_cursor # Add the term id and description cur.execute( """ INSERT OR ABORT INTO terms (name, desc) VALUES (?, ?)""", (term.name, term.desc), ) (TID,) = cur.execute("SELECT last_insert_rowid()").fetchone() if TID is None: # pragma: no cover # I dont know when this would happen without another exception being thrown raise ValueError(f"{term} was not assigned a valid TID!") for key, val in term.attrs.items(): cur.executemany(""" INSERT INTO term_attrs (TID, key, val) VALUES (?,?,?) """, ((TID,key,xval) for xval in val) ) # separate the new loci from the existing loci new_LIDs = [] existing_LIDs = [] for l in term.loci: try: existing_LIDs.append(self.loci._get_LID(l)) except MissingLocusError: new_LIDs.append(self.loci.add_locus(l, cur=lcur)) for LID in new_LIDs + existing_LIDs: cur.execute( """ INSERT INTO term_loci (TID,LID) VALUES (?,?) """, (TID, LID), ) if not cursor: cur.execute("END TRANSACTION")
Attaches to the gdbserver, running locally or portforwarded. If \|remote_address\| is set, it is used for ssh.	def _attach_bare_metal_gdb( remote_address, plugin_pid, ssh_options, nacl_helper_nonsfi_path, gdb_type): gdb_port = _get_bare_metal_gdb_port(plugin_pid) # Before launching 'gdb', we wait for that the target port is opened. _wait_by_busy_loop( lambda: _is_remote_port_open(_LOCAL_HOST, gdb_port)) gdb_args = [] if nacl_helper_nonsfi_path: gdb_args.append(nacl_helper_nonsfi_path) gdb_args.extend([ '-ex', 'target remote %s:%d' % (_LOCAL_HOST, gdb_port)]) gdb_args.extend(get_gdb_python_init_args()) library_path = os.path.abspath(build_common.get_load_library_path()) gdb_args.extend(get_gdb_python_script_init_args( 'bare_metal_support', arc_nexe=os.path.join( library_path, os.path.basename(build_common.get_runtime_main_nexe())), library_path=library_path, runnable_ld_path=os.path.join(library_path, 'runnable-ld.so'), lock_file=os.path.join(_BARE_METAL_GDB_LOCK_DIR, str(plugin_pid)), remote_address=remote_address, ssh_options=ssh_options)) gdb_args.extend(['-ex', r'echo To start: c or cont\n']) _launch_plugin_gdb(gdb_args, gdb_type)	def create_server_socket(self, local_address, peer, remote_address): self.server_sockets[local_address] = server_socket(self, local_address, peer, remote_address) self.server_sockets[local_address].run_thread.start()
호주는 임시직 시간제 공무원에게 본봉 외의 보수를 어떻게 주고 있지	3) 호주 호주의 공무원 임용은 정규직 전일제, 정규직 시간제 공무원, 임시직 전일제, 임시직 시간제 등 4가지로 분류된다. 전일제는 주 35시간 이상, 시간제는 주 35시간 미만 근무하는 것을 원칙으로 하며, 정규직 시간제 공무원의 경우 급여, 수당, 복지후생, 휴가 등 정규직 전일제공무원과 동등하다. 주당근무시간이 적으므로 급여나 수당 등이 전일제에 비해 적다. 임시직 시간제공무원의 경우 다른 정규직(전일제, 시간제 포함) 공무원과 임시직 전일제공무원의 임금, 수당, 휴가, 공휴일 규정이 적용되지 않는다. 기본급 이외의 수당이 지급될 경우 기본급의 15% 내외로 지급된다. 전체 공무원의 14%가 시간제공무원인 것으로 나타나고 있다.	□ 또한 고객으로부터 보수를 수취할 때에도 자문서비스를 제공하기 이전에 보상구조를 명시하도록 하고 이를 바탕으로 고객과 협상하여 자문보수를 결정하도록 함. ○ 영국의 경우 services and costs disclosure document나 combined initial disclosure document 중 적절한 것을 선택하여 서비스 제공이전에 고객에게 제시하도록 하고 있음. ○ 또한 영국은 총자문비용 공시에 대한 준칙을 적합성 보고서에 제공하도록 규제하고 있음. ○ 고객에게 제시한 보상구조 외의 여타 비용을 부과할 수 없으며 보상구조를 설명하는 내용에 거짓이 없어야 한다는 점도 규정 ○ 호주의 경우에도 수수료를 포함한 보수나 금전적 이익에 대한 정보 등을 Financial service guides(고객이 자문업자를 선택할 때 제공받는 자료), Statement of Advice(자문이 제공될 때 제공 받는 자료)등에 공시하도록 함. □ 나아가 유지관리와 관련된 보수의 경우, 자문업자가 서비스는 제대로 제공하지 않으면서 관련 보수만을 수취하는 경우가 발생하지 않도록 관련 내용을 명확히 공시하고 설명하도록 규정함. ○ 영국의 경우 유지관리 관련 보수(On going fee)를 상시적으로 수취하려면 고객에게 제공되는 서비스의 세부내역과 관련 수수료를 매칭하여 알려주고 만약 고객이 서비스를 중도에 취소하길 원한다면 지불을 중단할 수 있는 방법도 알려주도록 규제함. ○ 또한 유지관리관련 보수가 운용펀드의 일정 비율로 계산하여 수취하는 경우에는 펀드금액이 증가함에 따라 관련 지불금액 역시증가할 수 있다는 점을 고객에게 명시적으로 알려주도록 함. ○ 호주의 경우에도 영국과 유사하게 제공받는 서비스의 종류를 명시하고 취소방법 등을 알려주도록 규제하고 있음.
Sort the book based on the price (highest to lowest) and then the timestamp (earliest to latest).	def sort_orders(self): self.orders = sorted(self.orders, key=attrgetter('timestamp')) self.orders = sorted(self.orders, key=attrgetter('price'), reverse=True) #self.orders = sorted(self.orders, key=lambda order: order.timestamp) #print('<><><> BOOK AFTER ADD ORDER <><><>') #self.show_book() # print the book # size of order book after order added self.total_size_post_order = self.check_size() # what's the prize of the book (up to target_price shares) after order self.total_potential_price_post_trade = self.check_total_price()	def sortByRating(self): try: self.items.sort(key=lambda x: float(x[3]), reverse=False) except: pass
기획재정부가 달걀류 8가지 항목에 관한 할당관세 개정안을 결정한 건 언제야	기재부는 계란류 8개 품목 3만6,000톤에 대한 할당관세 규정 개정안도 이날 의결했다.	하지만 개정안이 통과돼도 일러야 9월에나 시행할 수 있는 데다, 예산을 쥔 기획재정부의 강력한 반대가 여전히 걸림돌이다.
광전류 봉우리를 세 군데에서 관측할 수 있는 이유가 뭐야?	광전류 봉우리는 세 곳에서 관측할 수 있는데 그 이유는 \( \mathrm{CdGa}_{2} \mathrm{Se}_{4} \) 단결정 박막은 육방정계 구조로 성장되어 spin-orbit splitting과 non cubic crystalline field 의 동시효과에 의하여 band splitting 이 일어난 것으로 볼 수 있다.	광전류 스펙트럼의 측정 에서 에너지 갭에 해당되는 가전자대에서 전도대로 들뜬 전자들에 의한 광전류 봉우리들과 단파장대에서 가 전자대 splitting에 의한 광전류 봉우리들이 관측되었다.
유럽부양규약은 개인정보 보호의 이익을 어떤 방식으로 감안하였어	유럽부양규약은 한편으로는, 중앙당국이 마련해 둔 정보만을 제공하도록 하고, 다른 한편으로는 제공할 정보를 주소, 소득, 사용자, 계좌보유 여부 및 재산 등으로 열거하는 방식을 통하여 개인정보 보호의 이익을 고려하였다. 이 규약에 따라 독일은 외국의 부양집행권원에 기한 강제집행과 관련하여 ｢국제 부양청구권 행사에 관한법률｣ 제17조에 중앙당국의 정보청구권과 정보의무를 규정해 놓고 있다. 위 법제17조의 규정 내용은 중앙당국이 법적 연금보험기관에 특히 당시의 사용자에 관한 정보를 조회할 수 있도록 하고, 4대보험기관에 구직자의 노무제공 현황을 조회하도록 하며, 연방국세청에 국세기본법 제93b조 제1항의 계좌정보를 조회할 수 있도록 하고 있다. 여기에 자동차에 대한 정보까지 규정하고 있어 대외부양법 제17조의 규정은 민사소송법상의 재산조회제도와 유사하다.	2. 영국 ｢익명화 실천규약｣의 주요내용 □ 영국 정보보호위원회 ｢익명화 실천규약｣은 일종의 안내서이기 때문에, 그 자체가 법적인 강제력을 가지는 것은 아니지만, 이 실천규약에서 규정한 사항들을 준수했다는 사실을 정보보호위원회가 확인할 경우, 이는 추후 정보보호위원회가 개인정보 보호와 관련한 법 위반 사실에 대한 조사나 법집행을 할 경우 적극적으로 고려하게 된다는 점에서, 이 규약은 간접적인 영향력을 지니는 가이드라인의 특성을 지니고 있다고 평가할 수 있음 □ 이 실천규약은 개인정보의 이용에 있어 보호업무를 충실히 수행하는 과정에서 유발될 수 있는 위험을 관리하는 방식으로 익명화를 소개하고 있음 ○ 우선 이 규약이 어떤 것이며 왜 등장했고 법적인 지위가 어떠한지(제1장)를 설명하고, 익명화라는 것은 개인정보의 정의와 분리하기 어려운 존재임을 밝힌 후(제2장), 개인정보의 익명화가 개인정보 보호에 효과적이라는 점을 설명함(제3장) ○ 이를 바탕으로 익명화된 정보를 생산하거나 공개할 때에 언제든지 정보주체의 동의가 필요한 것은 아니라는 점(제4장)과 공간정보를 개인정보처럼 취급해야 할지를 다룬 후(제5장), 개인정보 보호법제에 따라서는 공개해도 되는 정보도 인권법 같은 기타 법령에 의해 공개하지 말아야 하는 때가 있음(제6장)을 밝히고 있음 ○ 또한 개인정보 보호를 위해서는 정보의 유형별로 달리 취급될 필요가 있으며(제7장), 정보보호를 위한 거버넌스가 중요하다는 점(제8장) 및 보호와 이용의 균형을 위한 연구목적상 개인정보 보호법제의 적용예외(제9장)에 대해 설명하고 있음
Add InvertdIndex doc_index of the document doc_id to the MultiDocument InvertedIndex (inverted), using doc_id as document identifier.	def inverted_index_add(inverted, doc_id, doc_index): for word, locations in doc_index.iteritems(): indices = inverted.setdefault(word, {}) indices[doc_id] = locations return inverted	def _act_index_exact(fieldname, doc, value, context): doc.add_term(fieldname, value, 0)
초기 단계 조치에 따라 향후 몇 개월간 국제사회의 대이란 제재가 일부 완화될 수 있어	우리나라에 대한 2012년 미국 국방수권법상 대이란제재 예외 지위 연장 3. 한편, ‘P5+1’ 국가들(유엔 안보리 상임이사국인 미, 러, 중, 영, 프 5개국 및 독일)과 이란이 11.24(일) 제네바에서 합의한 ‘초기 단계 조치’에는, 이란 측의 약속 준수를 조건으로 향후 6개월간 국제사회의 대이란 제재가 일부 완화될 수 있다고 되어 있다. ㅇ 따라서, 앞으로의 이란산 원유 수입 감축 문제 등 제재 완화와 관련한 내용은 향후 제반 상황에 따라 구체화되어 갈 것으로 보며, 정부는 그 과정에서 관련 국가들과 필요한 협의를 해 나갈 예정이다. ※ 다만, 이번 제네바 합의에도 불구하고, 미국의「2013년 국방수권법」에 포함된 이란자유및반확산법(IFCA: Iran Freedom and Counterproliferation Act) 및 2010년 통합이란제재법(CISADA: Comprehensive Iran Sanctions, Accountability and Divestment Act) 등 다른 미국 법에 따른 대이란 제재는 지속 적용되므로 유의 필요 4. 우리 정부는 국제사회의 책임을 다하는 일원으로서 이란핵 문제의 평화적 해결을 위한 노력에 계속해서 적극 동참할 예정이며, 이러한 과정에서 우리 기업들이 불필요한 피해를 입지 않도록 앞으로도 최대한의 노력을 기울여 나갈 것이다.	글로벌 석유시장 변화를 원유수입다변화 기회로 3. 최근 석유시장 변화 및 대응 [ 이란제재 해제는 도입선 다변화의 기회 ] □ 전문가들은 내년도 상반기 이란 경제제재 해제로 이란산 원유가 시장에 공급될 경우 유가하락에 영향을 줄 것으로 전망 ㅇ 오랜 제재기간으로 이란 석유공급이 단기간내 제재전 수준으로 회복되기는 쉽지 않으나, 2016년에 50만～100만B/d 규모의 석유 공급이 가능하고, 3,000만B~6,000만B 규모의 해상재고를 보유하고 있어 향후 유가 하락요인으로 작용할 것으로 전망 * 이란제재 해제로 유가 추가하락을 전망하는 견해, 이미 유가에 선반영되어 있다는 견해가 있어 해제시 유가하락 규모에는 불확실성이 존재 □ 정유업계는 이란제재 해제시, 제재전 수준으로 이란 원유수입을 늘릴 것으로 전망 ㅇ 현재 이란산 원유수입은 제재 전과 비교하여 절반 수준으로 감소한 상황으로, 향후 컨덴세이트를 중심으로 이란원유에 대한 수요 증가 전망
Method is defined by the implemented data loaders to yield the sample indexes. Only used in data_generator.	def sample_index_generator(self): raise NotImplementedError	def get_sample(self, dataset, sample_idx): pass
check if loop brackets are balanced. if not exit assume the program was already sanitized from comments	def check_valid(program): balance = 0 for c in program: if c == '[': balance += 1 elif c == ']': balance -= 1 if balance < 0: print("\nERROR: Loop brackets not balanced", file=sys.stderr, flush=True) exit(-1) if balance > 0: print("\nERROR: Loop bracket not balanced, not enough closing", file=sys.stderr, flush=True) exit(-1)	def is_balanced(string: str) -> bool: open_brackets = {'(', '{', '['} close_brackets = {')', '}', ']'} bracket_pairs = { '}': '{', ')': '(', ']': '[' } stack = [] for bracket in string: if bracket in open_brackets: stack.append(bracket) elif bracket in close_brackets: if len(stack) and bracket_pairs[bracket] == stack[-1]: stack.pop() else: return False if not len(stack): return True return False
Return Relay vars from input shapes and create entries based on expected graph inputs to allow translation	def _get_relay_input_vars(graph, input_infos, prelude, is_module=True, default_dtype="float32"): graph_inputs = list(graph.inputs()) if is_module: # a module has "self" as first input, which we do not need/want graph_inputs = graph_inputs[1:] if not isinstance(input_infos, list): msg = "Graph inputs input_infos should be a list" raise RuntimeError(msg) if len(graph_inputs) != len(input_infos): msg = f"PyTorch has {len(graph_inputs)} inputs and input_infos lists {len(input_infos)}." raise RuntimeError(msg) def get_relay_ty(ishape, itype, pt_type): if pt_type.kind() == "TensorType": if not (_is_int_seq(ishape) or len(ishape) == 0): msg = "Shape for Tensors must be lists of ints" raise RuntimeError(msg) if (pt_type.dim() is not None and pt_type.dim() != len(ishape)) or ( pt_type.sizes() is not None and any([s1 != s2 for s1, s2 in zip(pt_type.sizes(), ishape)]) ): msg = "Shapes of input list and information in the graph do not match" raise RuntimeError(msg) if len(ishape) > 1 and any(dim <= 0 for dim in ishape[1:]): msg = ( "Expected input's non-batch dimensions to have positive length, " f"but input has a shape of {pt_type.sizes()}" ) raise RuntimeError(msg) pt_dtype = pt_type.scalarType() if not pt_dtype and itype: pt_dtype = itype dtype = _convert_data_type(pt_dtype, default_dtype=default_dtype) return TensorType(ishape, dtype) elif pt_type.kind() == "TupleType": if not isinstance(ishape, tuple): msg = "Shapes for tuples must be tuples" raise RuntimeError(msg) return TupleType( [get_relay_ty(elem, itype, pt_t) for elem, pt_t in zip(ishape, pt_type.elements())] ) elif pt_type.kind() == "ListType": if not isinstance(ishape, list): msg = "Shapes for lists must be lists" raise RuntimeError(msg) pt_elemtype = pt_type.getElementType() elem_tys = [get_relay_ty(s, itype, pt_elemtype) for s in ishape] if len(elem_tys) > 0 and not all(map(lambda ty: ty == elem_tys[0], elem_tys)): msg = "List elements need have identical types" raise RuntimeError(msg) rlist, _, _ = prelude.mod.get_type("List") return rlist(elem_tys[0]) elif pt_type.kind() == "OptionalType": # we do not support None yet, so we fill in the type return get_relay_ty(ishape, itype, pt_type.getElementType()) # TODO: scalar inputs raise NotImplementedError("unsupported input type") input_vars = {} new_input_infos = [] for num, inp in enumerate(input_infos): if not isinstance(inp, tuple): msg = f"Graph input {num} is not a tuple" raise RuntimeError(msg) if len(inp) != 2 or not isinstance(inp[0], str): msg = ( f"Graph input {inp} is not valid," f" expected ('name', shape) or ('name', (shape, dtype))" ) raise RuntimeError(msg) if not isinstance(inp[1], tuple) or len(inp[1]) == 0 or not isinstance(inp[1][-1], str): new_input_infos.append((inp[0], (inp[1], default_dtype))) else: new_input_infos.append(inp) input_types = [ (name, get_relay_ty(info[0], info[1], gi.type())) for (name, info), gi in zip(new_input_infos, graph_inputs) ] ir_inputs = [i.debugName() for i in graph_inputs] for ir_input, (name, itype) in zip(ir_inputs, input_types): inp = _expr.var(name, type_annotation=itype) # Translate from graph input to user input name input_vars[ir_input] = inp return input_vars	def parseInputs(): # Import past year's data data = {} # {year: df} # df row indices are months 0-11. colums are zones Z1-Z7 # values are energy consumption in that month in that zone, in GWh for year in const.DATA_YEARS: data[year] = pd.read_csv(f'{path}/{const.DATA_DIR}/NBTrend20{year}.csv', names=const.ZONES) # Import Incentive Rates incentiveRates = pd.read_csv(f'{path}/{const.INFO_DIR}/IncentiveRates.csv') emissionTax, nonEmissiveIncentive = incentiveRates.columns # $/kWh # Import Penalty Values penaltyValues = pd.read_csv(f'{path}/{const.INFO_DIR}/PenaltyValues.csv', names=const.PENALTY_ZONES) # Import Plant Production Rates plantProductionRates = pd.read_csv(f'{path}/{const.INFO_DIR}/PlantProductionRates.csv', names=const.PLANT_TYPES) return data, emissionTax, nonEmissiveIncentive, penaltyValues, plantProductionRates
This function creates a figure (chart) that is a Sankey Chart for the neighborhood that is input	def createSankeyChart(nbd): nbd_col = ( "neighbourhood_group_cleansed" if nbd == "All" else "neighbourhood_cleansed" ) if nbd != "All": three_proptype_df = rental_df[ rental_df["neighbourhood_group_cleansed"] == nbd ].copy() else: three_proptype_df = rental_df.copy() three_proptype_df = three_proptype_df[[nbd_col, "property_type_class"]].copy() # Limit types of property to House, Private Room and Shared Room three_proptype_df = three_proptype_df[ three_proptype_df["property_type_class"].str.contains( "House\|Private Room\|Shared Room\|Condominium\|Seviced apartment\|Apartment\|Townhouse" ) ] # we are not interested in Houseboats in the Sankey chart three_proptype_df = three_proptype_df[ ~three_proptype_df["property_type_class"].str.contains("Houseboat") ] label_list = three_proptype_df[nbd_col].unique().tolist() label_list.sort() label_list += three_proptype_df["property_type_class"].unique().tolist() # Create a new column count_listings with number of listings per neighborhood/neighborhood group and propert type sankey_df = three_proptype_df.groupby([nbd_col, "property_type_class"]).agg( count_listings=("property_type_class", "count") ) sankey_df = sankey_df.reset_index() # Create an dictionary of the indices of the nodes we are going to link (the sankey cchart links are created between these indices) label_idx_dict = {} for idx, label in enumerate(label_list): label_idx_dict[label] = idx # Use the dictionary to map the nodes to the indizes in the dataframe sankey_df["nbd_idx"] = sankey_df[nbd_col].map(label_idx_dict) sankey_df["prop_idx"] = sankey_df["property_type_class"].map(label_idx_dict) color_list = full_color_list[: len(three_proptype_df[nbd_col].unique().tolist())] group_color = dict(zip(list(sankey_df.groupby(nbd_col).groups.keys()), color_list,)) sankey_df["color_link"] = sankey_df[nbd_col].map(group_color) source = sankey_df["nbd_idx"].tolist() target = sankey_df["prop_idx"].tolist() values = sankey_df["count_listings"].tolist() # There are as many colors as nodes = 17 + 3 if nbd == "All": color_node = full_color_list + ["#befdb7", "#1B03A3", "#FEFCD7"] else: color_node = full_color_list[: len(label_list)] # For every neighborhood we use the same color for the link color_link = sankey_df["color_link"].tolist() fig = go.Figure( data=[ go.Sankey( node=dict( pad=15, thickness=20, line=dict(color="black", width=0.5), label=label_list, color=color_node, customdata=label_list, hovertemplate="%{customdata} has %{value} listings<extra></extra>", ), link=dict( source=source, target=target, value=values, color=color_link, hovertemplate="Link from %{source.customdata}<br />" + "to %{target.customdata}<br />has %{value} listings<extra></extra>", ), ) ] ) fig.update_layout( title_text="Available houses and rooms", font_size=12, title_font_color=dashboard_colors["medium-blue-grey"], font=dict(size=12, color=dashboard_colors["medium-blue-grey"]), ) # Set the theme fig.layout.template = "custom_dark" return fig	def show_custom_graph(self): pass
야외 캐노피/파티오의 비용은 얼마인가요?	일반적인 주택의 일반적인 창문에 대한 차양은 크기에 따라 300달러에서 700달러의 비용이 들 것입니다. 여기에는 프레임과 수동 리트랙션 메커니즘, 조립 하드웨어 및 설치 브래킷이 포함됩니다. 비리트랙션 금속 차양은 사용하기로 결정한 금속에 따라 500달러에서 800달러의 비용이 들 수 있습니다. 곰팡이 방지 처리를 적용하면 비용을 절감할 수 있으며, 변색 제거를 위한 청소 비용은 40달러입니다. 파티오용 모터화된 리트랙션 차양은 2,500달러에서 3,500달러의 비용이 들 수 있습니다.	패브릭 차양의 비용은 얼마인가요? 지역 파티오 및 경로 계약자에게 무료 견적을 받으세요. 야외 생활 공간에서 보내는 시간을 극대화하기 위해 그늘을 추가하는 것은 여름의 더위 속에서 무시되는 파티오와 오락에 적합한 분주한 파티오의 차이를 만들 수 있습니다.
Displays a text on the frame with a shadow behind it for better visualization on any background	def text_on_frame(frame, text, position, thickness, font_size=1, text_color=(255, 255, 255), shadow_color=(128, 128, 128), font_style=cv2.FONT_HERSHEY_SIMPLEX, line_style=cv2.LINE_AA): cv2.putText(frame, text, position, font_style, font_size, shadow_color, thickness+1, line_style) cv2.putText(frame, text, position, font_style, font_size, text_color, thickness, line_style)	def render_text(self, text, color, bg=None): return self.font.render(text, True, color, bg) # type: pygame.SurfaceType
Return the image from the input ``images`` list that has the largest overlap with the ``refimage`` image.	def max_overlap_image(refimage, images, enforce_user_order): if len(images) < 1: return None if enforce_user_order: # revert to old tweakreg behavior return images.pop(0) area = [refimage.intersection_area(im) for im in images] idx = np.argmax(area) return images.pop(idx)	def get_images_id_from_database(db, tags, img_type, use_count, limit): # First find intersection of each tag index in the databases all_tags_list = [] for tag in tags: coll = db[tag] raw_result = coll.find({}) image = [image['_id'] for image in list(raw_result)] result = db.images.find( {"_id" : {"$in" : image}, "img_type": img_type, "use_count": {"$gt": use_count}}, {"_id": 1}) images = [str(image['_id']) for image in list(result)] all_tags_list.append(images) id_list = set(all_tags_list[0]).intersection(all_tags_list[1:]) # Second, check whether we have to fetch more images from default image pool if len(id_list) >= limit: print("Get images from index!") images_list = id_list[:limit] else: print("Not enough images from index!") print("Try to find more in the default image pool!") coll = db['images'] # Then to find other images from the default image pool all_tags_list = [] for tag in tags: tag_str = 'tags.%s' % tag result = coll.find( {tag_str: {"$exists": True}, "img_type": img_type, "use_count": {"$gt": use_count}}, {"_id": 1}) images = [str(image['_id']) for image in list(result)] all_tags_list.append(images) images_list = list(set(all_tags_list[0]).intersection(all_tags_list[1:])) if len(images_list) >= limit: images_list = images_list[:limit] return images_list[:limit]
평평한 기판이란 무엇인가?	유리 기판은 액정 텔레비전(LCD), 플라즈마 텔레비전(PDP), 노트북 디스플레이와 같은 평판 디스플레이(FPD)를 만드는 시트 유리입니다. 이 재료는 창유리에 사용되는 시트 유리와 다릅니다. 액정 디스플레이와 플라즈마 디스플레이 간에도 재료가 다릅니다.	특히 중요하고 뉴스 가치가 있는 것은 갤럭시 S6 엣지(및 갤럭시 노트 엣지)의 유연한 플라스틱 기판에서의 OLED 디스플레이 성능이 갤럭시 S6의 전통적인 평면 및 단단한 기판에서의 성능과 본질적으로 동일하다는 점입니다. 이는 500픽셀 이상 및 2560x1440 해상도에서도 마찬가지입니다.
Count `constraints` for part one. Lines where `char` occurs at least `low` and at most `high` times.	def part_one(constraints: t.List[Constraint]) -> int: n_valid = 0 for low, high, char, password in constraints: n_valid += low <= password.count(char) <= high return n_valid	def main(text, char_lower, char_upper, total_lower, total_upper): answer_char, answer_total = [], [] _ = [char_lower.append(i) for i in text if i not in char_lower and i.islower()] _ = [char_upper.append(i) for i in text if i not in char_upper and i.isupper()] char_lower, char_upper = sorted(char_lower), sorted(char_upper) _ = [total_lower.append(text.count(i)) for i in char_lower] _ = [total_upper.append(text.count(i)) for i in char_upper] _ = answer_char.extend(char_lower), answer_char.extend(char_upper) _ = answer_total.extend(total_lower), answer_total.extend(total_upper) for i in range(len(answer_char)): total1, total2 = answer_total[i] // 5, answer_total[i] % 5 print("%s : %s" % (answer_char[i], (("-----\|" * total1 + "-" * total2).rstrip("\|"))))
This view should return a list of all the enrollments organized for the currently authenticated user's group.	def get_queryset(self): user = self.request.user if user.is_superuser: return Enrollment.objects.all() return Enrollment.objects.filter(organizer__in=user.groups.all())	def _GetEntitiesInEntityGroup(self, entity_group): raise NotImplementedError
Integration test with a real consul agent. Start a service, register it, close it, verify it's deregistered.	async def test_integration(self, deregister): tags = ("foo", "bar") service_id = str(uuid.uuid4()) # allow for parallel tests con = _LocalConsulAgentClient(token=None) ca = ConsulAgent( name="test-metrics", service_id=service_id, tags=tags, deregister=deregister, ) try: server = await aio.web.start_http_server( addr="127.0.0.1", service_discovery=ca ) except aiohttp.ClientOSError: pytest.skip("Missing consul agent.") svc = (await con.get_services())[service_id] assert "test-metrics" == svc["Service"] assert sorted(tags) == sorted(svc["Tags"]) assert server.socket.addr == svc["Address"] assert server.socket.port == svc["Port"] await server.close() services = await con.get_services() if deregister: # Assert service is gone iff we are supposed to deregister. assert service_id not in services else: assert service_id in services # Clean up behind ourselves. resp = await con.deregister_service(service_id) assert 200 == resp.status	def test_service_status_on_daemon_with_pid(): mock_service_list = ( '{\n\t"LimitLoadToSessionType" = "System";\n\t"Label" =' ' "com.salt";\n\t"OnDemand" = false;\n\t"LastExitStatus" = 0;\n\t"PID" =' ' 218;\n\t"Program" = "/opt/salt";\n\t\t"--disable-keepalive";\n\t);\n};' ) salt_dict = { "service.list": MagicMock(return_value=mock_service_list), } with patch.dict(mac_service.__salt__, salt_dict): with patch.object(mac_service, "_launch_agent", lambda _: False): with patch.object(mac_service, "_get_service", lambda _: {"": ""}): with patch.object( mac_service, "_always_running_service", lambda _: True ): assert mac_service.status("com.salt") is True
Counts the number of trainable tf.Variables to get a rough idea of how complex this Model is	def count_num_trainable(self): self.num_trainable_variables = 0 for variable in tf.trainable_variables(): # shape is an array of tf.Dimension shape = variable.get_shape() variable_parameters = 1 for dim in shape: variable_parameters *= dim.value self.num_trainable_variables += variable_parameters return self.num_trainable_variables	def param_size(model: torch.nn.Module) -> int: return sum(v.numel() for name, v in model.named_parameters() if "auxiliary" not in name)
This method accesses the get all profiles endpoint which takes a token since the route is authenticated	def get_all_profiles(self, token): return self.client.get( "/api/profiles/", HTTP_AUTHORIZATION='Bearer ' + token, format="json" )	def callback(): app = _get_app() app.authorize_access_token() return redirect(url_for('.profile'))
Returns the luminance of a pixel, which indicates its subjective brightness. This implementation uses the NTSC formula.	def luminance(pixel): r = GImage.getRed(pixel) g = GImage.getGreen(pixel) b = GImage.getBlue(pixel) return round(0.299 * r + 0.587 * g + 0.114 * b)	def __call__(self, image: np.ndarray) -> np.ndarray: if self.mode == "luminance": lum = hdrpy.get_lumianance(image) factor = 1. / np.amax(lum) else: factor = 1. / np.amax(image) return multiply_scalar(image, factor)
Run queued jobs. Since we've already sent the jobs to the PBS job system, don't do anything.	def run_queued_jobs(self): pass	def execute_queue(self): self.legacy_queue_execution()
Test _check_cache_for_egg checks the cache for the egg, returns path if present locally, or None if not.	def test_03_check_cache_for_egg(self): # Cleanup on isle one! launcher = ZMQEggDriverProcess("DUMMY_VAL") self.assertEqual(launcher._get_remote_egg(EGG), "/tmp/%s" % EGG) self.assertEqual(launcher._check_cache_for_egg("NOT_FOUND_EGG"), None) self.assertEqual(launcher._check_cache_for_egg(EGG), "/tmp/%s" % EGG)	def get(cache_dir=CACHE_DIR): current_wall = os.path.join(cache_dir, "pyc") if os.path.isfile(current_wall): return read_file(current_wall)[0] return "None"
부탄은 지도에서 어디에 위치해 있습니까?	부탄 지도는 부탄이 대 히말라야 산맥의 동쪽에 위치한 내륙 국가임을 보여줍니다. 부탄은 북쪽으로는 중국과, 남쪽으로는 인도와 국제 경계를 공유하고 있습니다.	부탄 및 인접 국가의 상세 지도. 구글 맵스 부탄 위치 목록에 오신 것을 환영합니다. 구글 맵스 관광이 의미 있는 곳에 오신 것을 환영합니다! 종합적인 목적지 안내서와 함께 maplandia.com은 상세한 위성 이미지를 통해 부탄을 탐험할 수 있도록 하여, 그 어느 때보다 빠르고 쉽게 가능합니다.
더덕김치, 있다, 오징어무말랭이김치	그것의 종류로는 더덕김치, 오징어무말랭이김치 등이 있다.	이곳의 밥상은 김치와 우거짓국, 그리고 무말랭이 버무린 것뿐이었다.
1985년부터 1997년까지 대한양궁협회장은 정몽구 현대차그룹 회장이 맡았고 2005년부터 여태까지는 정의선 부회장이 맡고 있는 중이다.	1985년부터 1997년까지 대한양궁협회장은 정몽구 현대차그룹 회장이었고 2005년부터 지금까지는 정의선 부회장이다.	1983년부터 1985년까지 재임한 초대 양궁협회장은 정몽준 아산재단 이사장이었고 뒤이어 정몽구 회장이 네 번 회장이 되었다.
Remove slave(s) from and existing zone (multiroom). Zone must already exist and slaves array cannot be empty.	def remove_zone_slave(self, slaves): if not slaves: _LOGGER.warning("Unable to find slaves to remove") else: _LOGGER.info( "Removing slaves from zone with master %s", self._device.config.name ) # SoundTouch API seems to have a bug and won't remove slaves if there are # more than one in the payload. Therefore we have to loop over all slaves # and remove them individually for slave in slaves: # make sure to not try to remove the master (aka current device) if slave.entity_id != self.entity_id: self._device.remove_zone_slave([slave.device])	def get_redis_slave_nodes(): az = _get_aci_client() return [cntr for cntr in az.container_groups.list() if _REDIS_SLAVE_REGEX.match(cntr.name)]
Stitch a series of images into an animation. Currently supports animated gifs, other formats coming as needed.	def stitch_to_animation(images, outpath=None, duration=0.5, palettesize=256, verbose=True): # import imageio try: import imageio except ImportError: raise ImportError( 'WrightTools.artists.stitch_to_animation requires imageio - https://imageio.github.io/') # parse filename if outpath is None: outpath = os.path.splitext(images[0])[0] + '.gif' # write try: t = wt_kit.Timer(verbose=False) with t, imageio.get_writer(outpath, mode='I', duration=duration, palettesize=palettesize) as writer: for p in images: image = imageio.imread(p) writer.append_data(image) except BaseException: print('Error: {0}'.format(sys.exc_info()[0])) return None # finish if verbose: interval = np.round(t.interval, 2) print('gif generated in {0} seconds - saved at {1}'.format(interval, outpath)) return outpath	def dream_seq(self): for i, path in enumerate(self.img_list[self.config["start_position"] :]): if i == 0: img1 = Image.open(path) d_img = self.deep_dream( self.transform(img1), self.model, i, seq="first" ) self.save_img(d_img, "", i) d_img = convert(d_img) flow_iter = 0 # the iterations needs to be reduced self.config["num_iterations"] -= 5 if i > 0: img2 = Image.open(path) feature_img, background_masked = self.get_opflow_image( img1, d_img, img2 ) feature_img = np.clip(feature_img, 0, 255) background_masked[background_masked > 0] = 1 - (flow_iter * 0.1) # 0.5 background_masked[background_masked == 0] = flow_iter * 0.1 d_img = self.deep_dream( self.transform(np.uint8(feature_img)), self.model, i, seq="first", mask=background_masked, ) # change position img1 = img2 self.save_img(d_img, "", i) d_img = convert(d_img) flow_iter += 1 flow_iter = 0 if flow_iter > 5 else flow_iter
Recives OCR text, extracts product. Text could contain garbage or wrong reads. >>> extract_product_from_text(''' ... d J	def extract_product_from_text(text): def extract(pattern): return extract_ocr_pattern(pattern, text) return { 'VENDORID': 1, 'VENDOR': 'example', 'ITEMNO': extract(r'ITEM ?ID(.)DESC'), 'DESCRIPTION': extract(r'DESC(.)UPC'), 'UPC': extract(r'UPC ?NO(.)WEIGHT'), 'COST': extract(r'PRICE(.?)\n'), }	def extract_text(self, input_file): logging.info("Extracting text from file " + input_file) try: tree = etree.parse(input_file) except etree.XMLSyntaxError: logging.error("XML syntaxerror in file " + input_file) if self.force: return else: sys.exit(-1) root = tree.getroot() for element in root.iter(): try: self.extract_element_info(element, input_file) except KeyError: pass
대마초가 소변에 얼마나 오래 남아 있는지	소변은 마리화나를 단 한 번 사용한 후 최대 8일 동안 THC 대사산물인 THC-COOH의 존재를 나타냅니다. 소변 검사 정확도는 약 일주일 후 감소하지만, 많은 빈번하거나 과도한 마리화나 사용자들은 각각 최대 15일 및 90일 동안 양성 반응을 보일 수 있습니다.	THC가 소변에 얼마나 오래 남아 있는지는 개인에 따라 다릅니다. 체중과 이전의 마리화나 노출은 테트라하이드로카나비놀(Tetrahydrocannabinol)이 체내에 얼마나 오래 남아 있을 수 있는지를 결정하는 주요 요인 중 일부입니다.
Setter method to set the next turn. Calls get turn and sets opposite player to next turn.	def set_next_turn(self): if self.get_turn() == 'B': self._turn = 'W' else: self._turn = 'B'	def set_next(self,next_class: 'Class') -> None: self.next = next_class
Return the second element of the given list. If the list has no second element, return None.	def select_second(L): if len(L)<2: return None return L[1]	def _return_elem_or_list(self, args): return args[0] if len(args) == 1 else args
Clear only parameter values, not the list of managed parameters. All parameters will be set to None.	def clear_parameter_values(self): for param_name in self.managed_parameters: self.managed_parameters[param_name] = None	def unfreeze_parameters(self): self.are_parameters_frozen = False
참여자, 종이, 메시지, 남기다, 응원	모든 참여자는 주어진 종이에 응원의 메시지를 남긴다.	재주라는 것은 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기다.
애플 TV 엔터테인먼트 채널은 몇 개입니까?	2007년에 처음 출시된 이후, 애플 TV는 단일 방송 네트워크에서부터 거의 20개의 한국 TV 네트워크를 하나의 채널로 집계한 것까지, 약 50개의 "채널" 또는 선호하는 용어인 앱을 보유하고 있습니다.	호주 내 인도 TV 및 라디오 채널. 인도 드라마, 음악 및 코미디 쇼 등은 모든 인도인의 마음에 가깝습니다. 우리는 인도 TV 채널과 라디오를 통해 인도와 연결되어 있다고 느낍니다. 인도 엔터테인먼트와의 연결을 유지하기 위해 호주에서 인도 TV 채널 및 라디오를 얻는 방법에 대한 포괄적인 목록을 확인하십시오: 인도 TV 채널 얻기: Yupptv: 호주에서 YuppTV를 통해 제공되는 인도 TV 채널.
가면라이더 디케이드의 필살기가 뭐야	또한 컴플리트 폼 상태에서 다른 라이더를 소환한 뒤 이 카드를 사용하면, 디케이드는 라이드 북커를 활용해서 자신과 똑같이 움직이는, 소환된 라이더와 함께, 소환된 라이더의 최종 형태가 사용하는 필살기를 시전한다. 디케이드는 디멘션 킥 이라는 라이더 킥을 필살기로 사용한다. 라이드 북커 소드 모드에서는 적을 힘껏 베는 디멘션 슬래시 를 사용할 수 있다. 또한 건 모드에서는 적에게 강력한 에너지탄을 쏘는 디멘션 블래스트 를 사용할 수 있다. 각 필살기를 사용할 때마다 디케이드의 파이널 어택 라이드 카드를 형상화한 환영들이 적을 향해 전개된다. 파이널 가면라이더 단말 K-터치 는 터치(터치스크린)폰(휴대폰)의 일종으로, 가면라이더 디케이드의 강화 변신 장비이다. 네거비트의 세계(가면라이더 디케이드의 새로운 세계의 등장 인물#네거티브의 세계)에서 츠카사가 손에 넣었다.	유키 조지가 변신하는 라이더맨은 극장판에서 모든 라이더들이 나타날 때 같이 등장했지만, 변신하는 장면은 묘사되지 않았다. 유키 조지의 인간 모습은 각트가 연기했으며, "The Next Decade"에서도 연기했다. 대쇼커는 수많은 악의 결사가 집합한 거대한 악의 조직이다. 로고는 원래의 쇼커 로고에 디케이드를 상징하는 "DCD"가 추가된 형태이다. 사신 박사(가면라이더 디케이드의 등장 인물#히카리 에이지로), 아폴로 가이스트(가면라이더 디케이드의 등장 인물#아폴로 가이스트) 외 역대 가면라이더 시리즈의 악당과 괴인들이 모여 있다. 지옥대사는 가면라이더의 세계(가면라이더)에서 온, 쇼커(쇼커 (가면라이더))의 간부이다. 방울뱀 형태의 가라가란다라는 괴인으로 변신할 수 있다.
Public method to get the word at the current position. the word at that current position (string)	def getCurrentWord(self): line, index = self.getCursorPosition() return self.getWord(line, index)	def echoPreviousWord(self, obj, offset=None): try: text = obj.queryText() except NotImplementedError: return if not offset: offset = text.caretOffset - 1 if (offset < 0): return [char, startOffset, endOffset] = \ text.getTextAtOffset( \ offset, pyatspi.TEXT_BOUNDARY_CHAR) if not self.utilities.isWordDelimiter(char): return # OK - we seem to be cool so far. So...starting with what # should be the last character in the word (caretOffset - 2), # work our way to the beginning of the word, stopping when # we hit another word delimiter. # wordEndOffset = offset - 1 wordStartOffset = wordEndOffset while wordStartOffset >= 0: [char, startOffset, endOffset] = \ text.getTextAtOffset( \ wordStartOffset, pyatspi.TEXT_BOUNDARY_CHAR) if self.utilities.isWordDelimiter(char): break else: wordStartOffset -= 1 # If we came across a word delimiter before hitting any # text, we really don't have a previous word. # # Otherwise, get the word. Remember we stopped when we # hit a word delimiter, so the word really starts at # wordStartOffset + 1. getText also does not include # the character at wordEndOffset, so we need to adjust # for that, too. # if wordStartOffset == wordEndOffset: return else: word = self.utilities.\ substring(obj, wordStartOffset + 1, wordEndOffset + 1) if self.utilities.linkIndex(obj, wordStartOffset + 1) >= 0: voice = self.voices[settings.HYPERLINK_VOICE] elif word.decode("UTF-8").isupper(): voice = self.voices[settings.UPPERCASE_VOICE] else: voice = self.voices[settings.DEFAULT_VOICE] word = self.utilities.adjustForRepeats(word) speech.speak(word, voice)
Wraps an agent's program function and prints the inputs/outputs, so you can watch it in its environment.	def trace_agent(agent:'agent') -> 'agent': old_program = agent.program def new_program(percept): action = old_program(percept) print('{} perceives {} and does {}'.format(agent, percept, action)) return action agent.program = new_program return agent	def foo(args): output("Foo!") return 0
Returns the index ID of the column. The structure of the CSV is defined in the configuration.	def __get_column_id(element: str) -> Optional[int]: idx = 0 for col in config.csv_headers: if col == element: return idx else: idx += 1	def ts_id_col(self): return self._ts_id_col if self._ts_id_col else ["ts_col_1"]
Representative content for a taxon. Will throw an error if the file it needs does not exist	def representative_content_for_taxon(taxon): # TODO: What to do about test/train content? representative_content_path = RepresentativeContent.path_for_representative_content(taxon) if os.path.exists(representative_content_path) and os.path.isfile(representative_content_path): most_representative_content = pd.read_csv(representative_content_path, low_memory=False) return most_representative_content['combined_text'].to_list() else: raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), f"Representative content file for {taxon.unique_title()} has not been generated, should be at: {representative_content_path}")	def usage(): with open('./usage.txt') as file_obj: contents = file_obj.read() return contents
그린스보로의 날씨는 어떤가요?	노스캐롤라이나 날씨 > 그린스보로 날씨. 그린스보로, NC의 기후는 여름에 기온이 70도대에 이르는 따뜻한 날씨를 보이며, 겨울에는 기온이 30도대에 이르는 매우 추운 날씨를 보입니다.	그린스보로 날씨 평균 및 기후 그린스보로, 노스캐롤라이나. 월별 온도, 강수량 및 일조 시간. 강수량 데이터, 온도 및 정상값을 보여주는 기후 그래프. 평균 날씨 그린스보로, NC.
Tests that newly created story cells decompose into concept cells, matching the concepts appearing in the text.	def test_cells_concept_extraction(self): # verify that the expected concepts do not exist self.assertEquals(0, ConceptCell.objects.filter(name="EveryBlock").count(), "Expected that the concept EveryBlock does not exist in the test fixtures") self.assertEquals(0, ConceptCell.objects.filter(name="Glenn").count(), "Expected that the concept Glenn Ford does not exist in the test fixtures") # add agents self.society_cell.add_agent("Bill", "Bill", DATASOURCE_TYPE_TWITTER) self.society_cell.add_agent("Al", "Al", DATASOURCE_TYPE_TWITTER) # fetch agents query = AgentCell.objects.filter(user__user_name="Bill") self.assertTrue(query.count() > 0, "Agent wasn't created") bill = query[0] query = AgentCell.objects.filter(user__user_name="Al") self.assertTrue(query.count() > 0, "Agent wasn't created") al = query[0] # add stories al.add_read_story("RT @yahoo RE YQL, EveryBlock API: were working \w senator Glenn Ford on all the details", [bill.user]) self.society_cell.process() # look up the concepts: YQL, EveryBlock, Glenn Ford self.assertEquals(1, ConceptCell.objects.filter(name="EveryBlock").count(), "Expected that the concept EveryBlock would be extracted from the added story") self.assertEquals(1, ConceptCell.objects.filter(name="Glenn").count(), "Expected that the concept Glenn Ford would be extracted from the added story") # get the concepts everyblock = ConceptCell.objects.filter(name="EveryBlock")[0] glenn = ConceptCell.objects.filter(name="Glenn")[0] # test concept recipient self.assertTrue(everyblock.recipients.all().count() > 0, "Expected to find reciipients for the new concepts") self.assertEquals(al.user, everyblock.recipients.all()[0], "Expected to find a specific recipient of the concept") self.assertTrue(glenn.recipients.all().count() > 0, "Expected to find reciipients for the new concepts") self.assertEquals(al.user, glenn.recipients.all()[0], "Expected to find a specific recipient of the concept")	def test_trait_count_12(self): things = self.model_factory.create_batch(20, source_study_version__i_is_deprecated=False) table = self.table_class(things) row = table.rows[0] n_traits = 12 factories.SourceTraitFactory.create_batch( n_traits, source_dataset=row.record) # Remake the table, to update trait counts. table = self.table_class(things) row = table.rows[0] self.assertEqual(row.get_cell('trait_count'), '{:,}'.format(n_traits))
Given an m x n matrix zero the rows and columns that have a 0 in it.	def zero_rows_columns(matrix): rows = [] columns = [] for i in range(len(matrix)): for j in range(len(matrix[0])): if matrix[i][j] == 0: rows.append(i) columns.append(j) for i in range(len(matrix)): for j in range(len(matrix[0])): if i in rows or j in columns: matrix[i][j] = 0 return matrix	def find_empty(board): for i in range(len(board)): for j in range(len(board[0])): if board[i][j] == 0: return i, j return None
미국 공군 사관학교는 어디에 있습니까?	포브스 리스트. 프로필. 미국 공군 사관학교는 콜로라도 스프링스, CO에 위치한 학생 사관생들을 위한 군사 서비스 아카데미로, 공군 기지로도 기능합니다. 공군은 공학 프로그램으로 유명하며, 이 학교는 국가 안보 연구소와 협력하여 광범위한 연구 기회와 보조금을 제공합니다.	미국 공군 사관학교. 미국 공군 사관학교(USAFA 또는 공군 사관학교로도 알려짐)는 미국 공군의 장교 후보생을 위한 군사 학교입니다. 이 캠퍼스는 미국 서부 콜로라도에 위치하고 있으며, 엘파소 카운티의 콜로라도 스프링스 바로 북쪽에 있습니다.
Disable Intan impedance testing Make sure DAQ is running, e.g. by calling startStreaming_boardSamples(), before calling this function.	def disableZCheck(): """ cmdData_DACconfig = ((0x1 << 24) \| (0xFF << 16) \| (0b10000101 << 8) \| 0) # clear register cmdData_DACchan = ((0x1 << 24) \| (0xFF << 16) \| (0b10000111 << 8) \| 0) # clear register """ #### cmds = [] #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, cmdData_DACconfig)) cmds.append(_intanRegWrite(address=5, data=0)) #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, cmdData_DACchan)) cmds.append(_intanRegWrite(address=7, data=0)) #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, 0)) # clear the CMD register cmds.append(_intanRegWrite(clear=True)) resps = _controlCmdWrapper(cmds)	def test_reportexclude(self): # default self.assertIsNone(self.settings.reportexclude) # turn things off options = random.randrange(1, 4) value = ''.join([random.choice('CDMSV') for option in xrange(options)]) self.settings.reportexclude = value self.assertEqual(' --reportexclude {0}'.format(value), str(self.settings)) # bad exclusion (number) with self.assertRaises(CameraobscuraError): self.settings.reportexclude = random.randrange(100) # invalid option with self.assertRaises(CameraobscuraError): self.settings.reportexclude = random.choice('ABEFGHIJKLNOP') return
마찰력이 강해져 원반이 엑스선을 방출할수 있게 뜨거워지면, 엑스선을 무엇으로 관찰 가능한가요?	블랙홀 강착을 일으키는 천체가 중성자별이나 블랙홀일 경우, 강착원반 안쪽의 가스는 밀집성 본체에 매우 가까워져 엄청난 고속으로 회전할 것이다. 그러면 마찰력이 너무 강해져서 원반이 전자기 복사(주로 엑스선)를 방출할 만큼 뜨거워진다. 이렇게 밝은 엑스선원들은 망원경으로 관측이 가능하다. 강착원반의 엑스선 방출은 지금까지 알려진 가장 에너지 효율이 높은 과정에 속한다. 항성 내부 핵융합이 질량의 0.7%를 에너지로 방출하는 반면, 강착원반은 질량의 40%를 복사 에너지로 방출시킨다. 많은 경우 강착원반은 밀집성의 양극 방향으로 분출되는 엄청난 에너지의 상대론적 제트를 수반한다. 이 제트가 만들어지는 과정은 현재로서 완전히 이해되지 못하고 있다.	블랙홀 찰스 토머스 볼튼, 루이스 웹스터(Louise Webster), 파울 무르딘(Paul Murdin)이 1972년에 최초의 강력한 블랙홀 후보 천체 백조자리 X-1를 이 방식으로 발견해냈다. 그러나 동반성이 블랙홀 후보보다 더 무거울 수 있기에 이 방법에는 다소의 불확실성이 남아 있다. 현재는 엑스선 쌍성계 중에서도 일시적 연엑스선(X-ray transients)으로 분류되는 계들에서 블랙홀 후보들이 보다 더 잘 발견된다. 이 종류의 쌍성계에서는 밀집성의 동반성의 질량이 상대적으로 작으며, 그 때문에 블랙홀의 질량을 보다 정확하게 추산할 수 있다. 또한 이들 계는 10 ~ 50년 동안 불과 수 개월 동안만 엑스선을 활발하게 방출한다. 엑스선 방출이 저조해지는 시기를 휴면기(quiescence)라 하며, 이 때 강착원반이 극도로 어두워져 동반성을 세밀하게 관측할 수 있게 된다. 이러한 블랙홀 후보 중 가장 적절한 예가 백조자리 V404이다.
Test that a ValueError gets raised when a required SignatureVerifyResponsePayload field is missing when encoding the struct.	def test_write_missing_validity_indicator(self): payload = signature_verify.SignatureVerifyResponsePayload( unique_identifier='49a1ca88-6bea-4fb2-b450-7e58802c3038' ) stream = utils.BytearrayStream() args = (stream, ) self.assertRaisesRegex( ValueError, "Payload is missing the validity indicator field.", payload.write, *args )	def test_some_missing_data(self, client): response = client.post( "/api/v1/register", data=json.dumps(some_missing), content_type='application/json;charset=utf-8') res_data = json.loads(response.get_data(as_text=True)) assert 'Bad Request' in res_data['status'] assert 'Missing data for required field.' in str(res_data['Message'])
Apply on a scalar field. If the argument is not a scalar field an error is raised.	def __call__(self, scalar_field): return self.v1(self.v2(scalar_field)) - self.v2(self.v1(scalar_field))	def alter_field(self, model, old_field, new_field, strict=False): # TODO : Logic to "upgrade" old data pass
solve_tsp solve the traveling salesman problem start with assignment model add cuts until there are no subcycles	def solve_tsp(V, c): # 部分巡回路除去製薬 def addcut(edges): G = nx.Graph() G.add_nodes_from(V) for (i, j) in edges: G.add_edge(i, j) Components = list(nx.connected_components(G)) if len(Components) == 1: return False for S in Components: model.addConstr(quicksum(x[i, j] for i in S for j in S if j > i) <= len(S) - 1) return True model = Model("tsp") x = {} for i in V: for j in V: x[i, j] = model.addVar(ub=1) model.update() for i in V: model.addConstr(quicksum(x[j, i] for j in V if j < i) + quicksum(x[i, j] for j in V if j > i) == 2) model.setObjective(quicksum(c[i, j] * x[i, j] for i in V for j in V if j > i), GRB.MINIMIZE) EPS = 1.e-6 while True: model.optimize() edges = [] for (i, j) in x: if x[i, j].X > EPS: edges.append((i, j)) if not addcut(edges): if model.IsMIP: break for (i, j) in x: x[i, j].VType = "B" model.update() return model.ObjVal, edges	def post_calc(self): # self.mfp = fcl.mean_free_path(self.solver_T, self.solver_p, # self.atmosphere.d) # self.Kn = self.mfp / self.spacecraft.L ## self.Re = fcl.KnReMa(self.atmosphere.k, Kn=self.Kn, ## Ma=self.Ma) # self.Re = fcl.Reynolds(self.solver_rho, self.V, self.spacecraft.L, # self.solver_mu) # Continuum: 0 < Kn < 0.001 # Slip: 0.001 <= Kn < 0.1 # Transition: 0.1 <= Kn < 10 # Free molecular: 10 < Kn self.regimes = placeholder() if len(np.argwhere(self.Kn > 10)) != 0: self.index_tran_freemol = np.argwhere(self.Kn > 10)[-1] self.regimes.free_molecular = np.argwhere(self.Kn >= 10) else: self.index_tran_freemol = None if len(np.argwhere(self.Kn > 0.1)) != 0: self.index_slip_tran = np.argwhere(self.Kn > 0.1)[-1] self.regimes.transition = np.argwhere((self.Kn < 10) & (self.Kn >= 0.1)) else: self.index_slip_tran = None if len(np.argwhere(self.Kn > 0.001)) != 0: self.index_cont_slip = np.argwhere(self.Kn > 0.001)[-1] self.regimes.slip = np.argwhere((self.Kn < 0.1) & (self.Kn >= 0.001)) else: self.index_cont_slip = None if len(np.argwhere((self.Kn > 0) & (self.Kn <= 0.001))) != 0: self.regimes.continuum = np.argwhere((self.Kn < 0.001) & (self.Kn >= 0)) else: self.index_cont_slip = None return [self.mfp, self.Kn, self.Re]
Get the auth time for the security context. Gets the auth time for the established security context.	def krb5_extract_authtime_from_sec_context( context: "SecurityContext", ) -> int:	def getServerTimeForOTP(self) -> datetime.datetime: # This method seems to be useless to generate the OTP(One Time Password), but I leave it there if not self.__connected: raise ConnectionError r = self.__s.get(f"{BASE_URL}/nvsecurityapi/rest/enrollments/time") httpTime = r.headers["Date"] time = datetime.datetime.strptime( httpTime, '%a, %d %b %Y %H:%M:%S GMT') return time
Shows ann error if the user specifies an overly complicated system that requires too much memory allocation.	def show_size_error(self): messagebox.showerror(title = 'Memory Error', message = 'The parameters ' + 'you have specified require too much memory to be ' + 'computed. Please decrease the simulation time ' + 'and/or the transport rates to rectify this issue.') self.frame.quit()	def test_memory_usage(self): manager = ApacheManager() # Make sure there are Apache workers alive that have handled a couple of requests. for i in range(10): manager.fetch_status_page(manager.text_status_url) assert sum(manager.memory_usage) > 0 # TODO Create a WSGI process group so we can perform a useful test here? assert isinstance(manager.wsgi_process_groups, dict)
Adds an occupant to its list of occupants to keep track of as well as the rlt	def add(self, o): self.__occupants.append(o[0]) self.__position_rlt[o[0]] = (o[1], o[2])	def increment_room_occupancy(room, occupancy_additional): with sqlite3.connect(database) as c: c.execute('''CREATE TABLE IF NOT EXISTS rooms (name text UNIQUE, capacity integer, occupancy integer, noiseLevel integer);''') validate_room(room) current_occupancy = c.execute('''SELECT occupancy FROM rooms WHERE name=?;''', (room,)).fetchone()[0] new_occupancy = current_occupancy + occupancy_additional c.execute('''UPDATE rooms SET occupancy=? WHERE name=?;''', (new_occupancy, room))
Writes output matches to a file in the subfolder "Matches". It supports any iterable as output matches.	def file_output(matches: list, output_file_name: str = 'matches.txt'): with open("test/Matches/" + output_file_name, 'w') as f: for match in matches: for event in match.events: f.write("%s\n" % event.payload) f.write("\n")	def write(afile, seqs): for s in seqs : writeseq(afile, s)
Return whether finding group list for a specified node is supported by the resolver (in optional namespace).	def has_node_groups(self, namespace=None): try: return bool(self._source(namespace).reverse_upcall) except GroupResolverSourceError: return False	def is_in_group(user, group_name): return user.groups.filter(name__exact=group_name).exists()
A callback method that is called when the desired properties of the devices device twin are updated.	def on_device_twin_desired_updated(self): return self._on_device_twin_desired_updated	def set_update_callback(self): pass
군청, 직원, 젊다, 상냥하다	군청의 젊은 직원이 유독 무척 상냥한 것 같다.	재주는 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기 등등 이다.
inherits the __init__ from Number if just normal number or uses new method if its a list.	def __init__(self, number=None): if type(number) != list: print("hei") super().__init__(float(number)) elif type(number) == list: self.number = [] for i in number: self.number.append(i) else: raise TypeError("number added inn does not fill any of the type categories ´int/float/list´")	def __new__(args, *kwargs): # real signature unknown pass
Iteratively zoom in on the minimum position in an image until the deltapeak value is below `mindiff`	def iterative_zoom(image, mindiff=1., zoomshape=[10,10], return_zoomed=False, zoomstep=2, verbose=False, minmax=np.min, ploteach=False, return_center=True): image_zoom = image argminmax = np.argmin if "min" in minmax.__name__ else np.argmax zf = 1. # "zoom factor" initialized to 1 for the base shift measurement offset = np.array([0]image.ndim,dtype='float') # center offset delta_image = (image_zoom - minmax(image_zoom)) xaxzoom = np.indices(image.shape) if ploteach: ii = 1 pl.figure(ii) pl.clf() pl.pcolor(np.arange(image.shape[0]+1)-0.5,np.arange(image.shape[1]+1)-0.5, image) minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) pl.plot(minpos[1],minpos[0],'wx') # check to make sure the smallest nonzero* difference > mindiff while np.abs(delta_image[np.abs(delta_image)>0]).min() > mindiff: minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) center = xaxzoom[0][minpos],xaxzoom[1][minpos] offset = xaxzoom[0][minpos]-(image.shape[0]-1)/2,xaxzoom[1][minpos]-(image.shape[1]-1)/2 zf *= zoomstep xaxzoom, image_zoom = zoom.zoom_on_pixel(image, center, usfac=zf, outshape=zoomshape, return_xouts=True) delta_image = image_zoom-minmax(image_zoom) # base case: in case you can't do any better... # (at this point, you're all the way zoomed) if np.all(delta_image == 0): if verbose: print("Can't zoom any further. zf=%i" % zf) break if verbose: print(("Zoom factor %6i, center = %30s, offset=%30s, minpos=%30s, min\|diff\|=%15g" % (zf, ",".join(["%15g" % c for c in center]), ",".join(["%15g" % c for c in offset]), ",".join(["%5i" % c for c in minpos]), np.abs(delta_image[np.abs(delta_image)>0]).min() ))) if ploteach: ii += 1 pl.figure(ii) pl.clf() pl.pcolor(centers_to_edges(xaxzoom[1][0,:]),centers_to_edges(xaxzoom[0][:,0]),image_zoom) pl.contour(xaxzoom[1],xaxzoom[0],image_zoom-image_zoom.min(),levels=[1,5,15],cmap=pl.cm.gray) pl.plot(center[1],center[0],'wx') minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) pl.plot(xaxzoom[1][minpos], xaxzoom[0][minpos], 'w+') pl.arrow(center[1],center[0],xaxzoom[1][minpos]-center[1],xaxzoom[0][minpos]-center[0],color='w', head_width=0.1/zf, linewidth=1./zf, length_includes_head=True) pl.figure(1) #pl.contour(xaxzoom[1],xaxzoom[0],image_zoom-image_zoom.min(),levels=[1,5,15],cmap=pl.cm.gray) pl.arrow(center[1],center[0],xaxzoom[1][minpos]-center[1],xaxzoom[0][minpos]-center[0],color='w', head_width=0.1/zf, linewidth=1./zf, length_includes_head=True) if return_center: result = center else: result = offset if return_zoomed: return image_zoom,zf,result else: return result	def initial_guess(cts, xmin, xmax, size_window_background_left, size_window_background_right): # Automatic finding peak parameters number_of_image = len(cts) # nbre of images in the scan add_x0 = 0 add_IM = 0 add_H = 0 add_A = 0 add_B = 0 for ii in range(number_of_image): number_of_pixel = len(cts[ii]) x = np.arange(0, number_of_pixel, 1) step = x[1] - x[0] # Obtaining and add x0, IM and H add_x0 += (xmin + list_manipulation.index(cts[ii][xmin:xmax], max(cts[ii][xmin:xmax]))) add_IM += max(cts[ii][xmin:xmax]) add_H += (trapeze_method(cts[ii][xmin:xmax], step) / max(cts[ii][xmin:xmax])) # Obtaining A and B background_left = cts[ii][xmin:xmin + size_window_background_left] background_right = cts[ii][xmax - size_window_background_right:xmax] left_point_value = np.mean(background_left) right_point_value = np.mean(background_right) left_point_absc = xmin + size_window_background_left / 2 right_point_absc = xmax - size_window_background_right / 2 B_temp = (left_point_value - right_point_value) / (left_point_absc - right_point_absc) A_temp = left_point_value - B_temp * left_point_absc add_A += A_temp add_B += B_temp x0 = add_x0 / number_of_image IM = add_IM / number_of_image H = add_H / number_of_image A = add_A / number_of_image B = add_B / number_of_image return x0, IM, H, A, B
BOOL SQLInstallTranslatorEx( LPCTSTR lpszTranslator, LPCTSTR lpszPathIn, LPTSTR lpszPathOut, WORD cbPathOutMax, WORD pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount )	def odbccp32_SQLInstallTranslatorEx(jitter, get_str, set_str): ret_ad, args = jitter.func_args_stdcall(["lpszTranslator", "lpszPathIn", "lpszPathOut", "cbPathOutMax", "pcbPathOut", "fRequest", "lpdwUsageCount"]) raise RuntimeError('API not implemented') jitter.func_ret_stdcall(ret_ad, ret_value)	def odbccp32_SQLInstallTranslator(jitter, get_str, set_str): ret_ad, args = jitter.func_args_stdcall(["lpszInfFile", "lpszTranslator", "lpszPathIn", "lpszPathOut", "cbPathOutMax", "pcbPathOut", "fRequest", "lpdwUsageCount"]) raise RuntimeError('API not implemented') jitter.func_ret_stdcall(ret_ad, ret_value)
Helper function that returns the AmpLayout.Layout name for a given index. See amp.validator.AmpLayout.Layout in validator.proto for details.	def GetLayout(validator_pb2, layout_index): amp_layout = validator_pb2.DESCRIPTOR.message_types_by_name['AmpLayout'] layouts = amp_layout.fields_by_name['supported_layouts'].enum_type.values return layouts[layout_index].name	def get_label(index): if index == 0: return "Sepal Length" if index == 1: return "Sepal Width" if index == 2: return "Petal Length" if index == 3: return "Petal Width"
when removing a room we wan't to be able to remove it from the cache as well	def remove_room_exists(self, channel_id, room_id):	def rm_from_cache(self, args, kwargs): try: del self._cache[self._prehash( bind_callargs(self._signature, args, **kwargs) )] except KeyError: pass
Generates a trajectory given a path. Does it using splines for each of the x, y, z	def create_trajectory(self, path): # Added this last pose because in some cases the drone would stop at the before-last pose. # Couldn't figure out the reason for this, I plotted the splines and they seemed fine. It # looks like some bug in the crazyflie firmware. path.add_pose(path.poses[-1], path.times[-1] + EPS) self.__duration = path.times[-1] # Generates splines for x, y and z, using the t array as knots. x_spline = CubicSpline(path.times, [p.position().x for p in path.poses], bc_type='natural') y_spline = CubicSpline(path.times, [p.position().y for p in path.poses], bc_type='natural') z_spline = CubicSpline(path.times, [p.position().z for p in path.poses], bc_type='natural') # Passing to the structure ros will read. Note that the polynomials must have 8 constants. for i in range(1, len(path.times)): x_coef = np.concatenate((x_spline.c[:, i - 1][::-1], [0] * 4)) y_coef = np.concatenate((y_spline.c[:, i - 1][::-1], [0] * 4)) z_coef = np.concatenate((z_spline.c[:, i - 1][::-1], [0] * 4)) p = Polynomial4D(path.times[i] - path.times[i - 1], x_coef, y_coef, z_coef, [0] * 8) self.__polynomials.append(p)	def generate_spiral_path_dtu(poses, n_frames=120, n_rots=2, zrate=.5, perc=60): # Get radii for spiral path using 60th percentile of camera positions. positions = poses[:, :3, 3] radii = np.percentile(np.abs(positions), perc, 0) radii = np.concatenate([radii, [1.]]) # Generate poses for spiral path. render_poses = [] cam2world = poses_avg(poses) up = poses[:, :3, 1].mean(0) z_axis = focus_pt_fn(poses) for theta in np.linspace(0., 2. * np.pi * n_rots, n_frames, endpoint=False): t = radii * [np.cos(theta), -np.sin(theta), -np.sin(theta * zrate), 1.] position = cam2world @ t render_poses.append(viewmatrix(z_axis, up, position, True)) render_poses = np.stack(render_poses, axis=0) return render_poses
Unlike a given repo on the Hub (e.g. remove from favorite list). See also [`like`] and [`list_liked_repos`].	def unlike( self, repo_id: str, *, token: Optional[str] = None, repo_type: Optional[str] = None, ) -> None: if repo_type is None: repo_type = REPO_TYPE_MODEL response = get_session().delete( url=f"{self.endpoint}/api/{repo_type}s/{repo_id}/like", headers=self._build_hf_headers(token=token) ) hf_raise_for_status(response)	def repository(full_name): session = db.get_session() try: repository = session.query(Repository) \ .filter(Repository.full_name == full_name) \ .one() commit_shas = session.query(Commit.sha) \ .join( commit_repository, commit_repository.c.repository_clone_url == repository.clone_url, ) \ .filter(commit_repository.c.commit_sha == Commit.sha) \ .all() commit_shas = [c[0] for c in commit_shas] if commit_shas: session.query(Commit) \ .filter(Commit.sha.in_(commit_shas)) \ .delete(synchronize_session=False) session.query(Repository) \ .filter(Repository.full_name == full_name) \ .delete() session.commit() finally: session.close()
국외로 나가지 않고도 베를린 필하모닉 오케스트라가 운영하는 공연 실황중계 시스템을 통해 공연을 관람할 수 있다.	베를린 필하모닉 오케스트라가 공연 실황중계 시스템을 구축함으로 인해 국내에서도 인터넷을 통해 공연 관람이 가능하다.	서로가 하는 공연 관람을 서울, 부산을 오가며 했고 공연을 마치면 함께 소주를 마셨다.
The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.	def drain_timeout_in_sec(self) -> int: return pulumi.get(self, "drain_timeout_in_sec")	def KeepAliveTimeout(self): return self._get_attribute('keepAliveTimeout')
걔가 한 달에 버는 돈은 얼마야	걔가 한 달에 버는 돈이 되는데?	그러면 갈 때마다 얼마씩 걷는 거야 아니며 매달 얼마씩 걷는 거야?
Goes through all functions to calculate all important numbers for the tree Calculates num_child, num_grand, tree_size, depth	def calc_all(self): self.calc_num_child() # calculate number of children self.calc_num_grand() # calculate number of grandkids self.calc_tree_size() # calculate number of tree size self.calc_depth() self.calc_max_depth()	def calc_num_child(self): self.num_child = len(self.children) # count num of kids for child in self.children: # Go thru all kids child.calc_num_child() # Ask each kid to take stock also
Fit a quadratic around a point and find its local minimum/maximum Center should be in row,column format	def fitquadratic(im,center,n): w = int((n-1)/2) start = center - w patch = im[start[0]:(start[0]+n), start[1]:(start[1]+n)] x0 = (n+1)/2 x,y = np.meshgrid(range(n),range(n)) x = x.flatten()+1-x0 y = y.flatten()+1-x0 # Constants for coefficient vector [f a b c d e] A = np.vstack([np.ones(nn), x2, y2, xy, x, y]).T coef = np.linalg.lstsq(A, patch.flatten())[0] # Find minimum coordinates B = np.array([[2coef[1], coef[3]], [coef[3], 2coef[2]]]) rhs = np.array([[-coef[4]],[-coef[5]]]) # [2a c; c 2b][x;y]=-[d;e] xymin = np.linalg.lstsq(B,rhs)[0] xymin += np.array([[center[1]],[center[0]]]) return xymin, coef	def closest_point_to(self, x): min_pt, min_dist = None, np.inf for s in self.segments: s_min_dist, s_min_pt = s.closest_point_to(x) if s_min_dist < min_dist: min_dist = s_min_dist min_pt = s_min_pt sd = np.copysign(min_dist, -1 if self.is_inside(x) else 1) return sd, min_pt
Return an instance of BlackjackMDP where peeking is the optimal action at least 10% of the time.	def peekingMDP(): # BEGIN_YOUR_CODE (our solution is 2 lines of code, but don't worry if you deviate from this) return BlackjackMDP(cardValues=[4, 5, 10, 11], multiplicity=1, threshold=20, peekCost=1) # END_YOUR_CODE	def _greedy_policy(self, state): raise NotImplementedError
인큐베이터에서 병아리 알을 부화하는 데 얼마나 걸립니까?	그렇다면 수정된 닭 알이 부화하는 데 얼마나 걸릴까요? 그에 대한 답은 정확히 21일입니다. 그러나 여러 가지 상황에 따라 달라질 수 있다는 점을 염두에 두어야 합니다. 어떤 이유로 인해 온도가 적정 온도 이하로 떨어진 경우, 일부 알은 22일, 23일, 또는 심지어 24일이나 25일에 부화할 수 있습니다. 수정된 닭 알은 일반적으로 정확히 21일이 걸리는 반면, 대부분의 오리 알은 28일이 걸리며, 무스코비 오리를 제외합니다.	닭 알은 일반적으로 부화하기 전에 약 21일 동안 인큐베이션됩니다.
민준이, 여름, 휴가, 기차, 여행, 떠나다, 하다	민준이는 여름 휴가로 혼자 기차 여행을 떠나기로 했다.	재주는 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기 등등 이다.
전자 환원반응을 통해 세포와 조직에 독성을 일으키는건 뭐야?	\( \mathrm{O}_{2}^{-} \)은 전자 환원반응을 통해 세포와 조직에 독성을 일으켜 질병을 유발시키며, 이는 노화와 밀접한 관련이 있는 것으로 알려져 있다.	이는 본 연구에서 농화배양된 혼합미생물이 환원전극 반응기 내에서 전극으로 부터 전자를 받아 \( \mathrm{CO}_{2} \) 를 아세트산으로 환원하는 생물전기활성반응을 일으키는 것을 나타낸다.
사용되다, 치료제, 통증, 봉독	봉독은 주로 통증 치료제로 사용되어 왔다.	샐러드의 양념으로 주로 소금, 후추, 향료, 케이퍼 등이 사용되고 있다.
Return a dictionary of css dictionaries representing this scheme. This can be fed to the ly.colorize.format_stylesheet() function.	def css_scheme(self): scheme = {} # base/default styles d = scheme[None] = {} for name, fmt in self.defaultStyles.items(): d[name] = fmt2css(fmt) # mode/group styles for mode, styles in self.allStyles.items(): d = scheme[mode] = {} for name, fmt in styles.items(): d[name] = fmt2css(fmt) return scheme	def stylers(self): if self._stylers is None: self._stylers = styler_factory(self.project_config().get('style', {})) return self._stylers
Verifies that the report is not accredited if it contains a sample application that is not accredited.	def test_get_report_accreditation_false(report_api_mip_dna, mip_analysis_api, case_mip_dna): # GIVEN a list of samples when one of them is not accredited mip_metadata = mip_analysis_api.get_latest_metadata(case_mip_dna.internal_id) samples = report_api_mip_dna.get_samples_data(case_mip_dna, mip_metadata) samples[0].application.accredited = False # WHEN retrieving the report accreditation accredited = report_api_mip_dna.get_report_accreditation(samples) # THEN check that the report is not accredited assert not accredited	def test_get_sample_bad_sample(cli_runner: CliRunner, base_context: CGConfig): # GIVEN an empty database # WHEN getting a sample name = "dummy_name" result = cli_runner.invoke(get, ["sample", name], obj=base_context) # THEN it should warn about missing sample id instead of getting a sample # it will not fail since the API accepts multiple samples assert result.exit_code == 0
Search for documents based on type filters, search_text or order_by and return a queryset of document objects	def search_documents(self, types=None, search_text=None, order_by=None): documents = self if types and isinstance(types, list) and types[0] != 'all': documents = documents.filter(type__in=types) if search_text: documents = documents.filter(Q(name__icontains=search_text) \| Q(description__icontains=search_text) \| Q(search__icontains=search_text)) if order_by: # TODO: Validate that order_by is a valid sort parameter documents = documents.order_by(order_by) return documents	def search(self, query_string, fields=None, backend='default'): search_backend = get_search_backend(backend) return search_backend.search(query_string, self, fields=None)
Performs a single read from the socket and hands the data off to the h2 connection object.	def _single_read(self): # Begin by reading what we can from the socket. # # Concurrency # # Synchronizes reading the data # # I/O occurs while the lock is held; waiting threads will see a delay. with self._lock: if self._sock is None: raise ConnectionError('tried to read after connection close') self._sock.fill() data = self._sock.buffer.tobytes() self._sock.advance_buffer(len(data)) with self._conn as conn: events = conn.receive_data(data) stream_ids = set(getattr(e, 'stream_id', -1) for e in events) stream_ids.discard(-1) # sentinel stream_ids.discard(0) # connection events self.recent_recv_streams \|= stream_ids for event in events: if isinstance(event, h2.events.DataReceived): self._adjust_receive_window(event.flow_controlled_length) self.streams[event.stream_id].receive_data(event) elif isinstance(event, h2.events.PushedStreamReceived): if self._enable_push: self._new_stream(event.pushed_stream_id, local_closed=True) self.streams[event.parent_stream_id].receive_push(event) else: # Servers are forbidden from sending push promises when # the ENABLE_PUSH setting is 0, but the spec leaves the # client action undefined when they do it anyway. So we # just refuse the stream and go about our business. self._send_rst_frame(event.pushed_stream_id, 7) elif isinstance(event, h2.events.ResponseReceived): self.streams[event.stream_id].receive_response(event) elif isinstance(event, h2.events.TrailersReceived): self.streams[event.stream_id].receive_trailers(event) elif isinstance(event, h2.events.StreamEnded): self.streams[event.stream_id].receive_end_stream(event) elif isinstance(event, h2.events.StreamReset): if event.stream_id not in self.reset_streams: self.reset_streams.add(event.stream_id) self.streams[event.stream_id].receive_reset(event) elif isinstance(event, h2.events.ConnectionTerminated): # If we get GoAway with error code zero, we are doing a # graceful shutdown and all is well. Otherwise, throw an # exception. self.close() # If an error occured, try to read the error description from # code registry otherwise use the frame's additional data. if event.error_code != 0: try: name, number, description = errors.get_data( event.error_code ) except ValueError: error_string = ( "Encountered error code %d" % event.error_code ) else: error_string = ( "Encountered error %s %s: %s" % (name, number, description) ) raise ConnectionError(error_string) else: log.info("Received unhandled event %s", event) self._send_outstanding_data(tolerate_peer_gone=True, send_empty=False)	def read(self): assert self.status in (WAIT_LEN, WAIT_MESSAGE) if self.status == WAIT_LEN: self._read_len() # go back to the main loop here for simplicity instead of # falling through, even though there is a good chance that # the message is already available elif self.status == WAIT_MESSAGE: read = self.socket.recv(self.len - len(self.message)) if len(read) == 0: logging.error("can't read frame from socket (get %d of %d bytes)" % (len(self.message), self.len)) self.close() return self.message += read if len(self.message) == self.len: self.status = WAIT_PROCESS
Verify that a generated quote came from a trusted TPM and matches the previously obtained PCR values	def quote_verify(data, validation, aik, pcrvalues): select = 0 maxpcr = 0 # Verify that the validation blob was generated by a trusted TPM pubkey = aik.get_pubkey() n = m2.bin_to_bn(pubkey) n = m2.bn_to_mpi(n) e = m2.hex_to_bn("010001") e = m2.bn_to_mpi(e) rsa = M2Crypto.RSA.new_pub_key((e, n)) m = hashlib.sha1() m.update(data) md = m.digest() try: ret = rsa.verify(md, str(validation), algo='sha1') except M2Crypto.RSA.RSAError: return False # And then verify that the validation blob corresponds to the PCR # values we have values = bytearray() for pcr in sorted(pcrvalues): values += pcrvalues[pcr] select \|= (1 << pcr) maxpcr = pcr if maxpcr < 16: header = struct.pack('!H', 2) header += struct.pack('@H', select) header += struct.pack('!I', len(values)) else: header = struct.pack('!H', 4) header += struct.pack('@I', select) header += struct.pack('!I', len(values)) pcr_blob = header + values m = hashlib.sha1() m.update(pcr_blob) pcr_hash = m.digest() if pcr_hash == data[8:28]: return True else: return False	def test_change_secret(self): sig1 = self.notary.compute_signature(self.nb) self.notary.secret = b"different" sig2 = self.notary.compute_signature(self.nb) self.assertNotEqual(sig1, sig2)
this function returns the list of animals with a new session within the last few ('days_passed') days	def get_current_animals(root: Root, days_passed: int = 4): now = datetime.datetime.now() all_animals = root.get_all_animals() if all_animals == []: logging.warning('No animal found!') return [] animalList = [] for animal in all_animals: animalTag = File(root, animal) sessionList = animalTag.get_all_sessions() if not sessionList: continue lastSessionDate = animalTag.get_session_date(sessionList[-1]) if (now - lastSessionDate).days <= days_passed: animalList.append(animal) return animalList	def ended_recently(self): return self.filter( status=Contest.CLOSED, created_at__gt=timezone.now()-(SUBMISSIONS_LENGTH+VOTING_LENGTH+RECENT_LENGTH) ).order_by("-created_at")
Activated at the end of the with statement. It automatically releases the lock if it isn't locked.	def __exit__(self, exc_type, exc_val, exc_tb): if self.is_locked: self.release()	def unlock(self): utilities.lock.unlock(self.lockfd)
Returns the mean squared error for model (a polynomial of the specified degree) on X and y.	def mse(X, y, degree, model): # calculate MSE for X and y and return both MSE_x = np.square(np.subtract(X, model[0])).mean()/len(X) MSE_y = np.square(np.subtract(y, model[1])).mean()/len(y) return MSE_x, MSE_y	def error(self, x: np.array, y: np.array) -> float: yh = self.predict(x) return np.mean(y != yh)
있다, 실속, 땅, 땅, 가치, 귀하다	그 땅은 실속이 있고 경제적 가치가 귀한 땅이다.	수박, 참외, 조롱박, 수세미, 오이, 가지를 정성껏 심어 무럭무럭 키웠다.
통영시와 통영 폐조선소 재생사업 협약을 체결한 건 어디지?	한국토지주택공사(LH)는 통영시 소재 신아sb조선소에서 경상남도, 통영시와 통영 폐조선소 재생사업 기본협약을 체결했다고 30일 밝혔다	한국토지주택공사(LH)는 통영 폐조선소 재생사업 마스터플랜 국제공모 당선작으로 포스코에이앤씨 컨소시엄의 통영 캠프 마레를 최종선정했다고 10일 밝혔다
Given a RefID and an optional name, create a profile and then return that newly created profile.	def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], pid: Optional[int]) -> ValidatedDict: if refid is None: return None if name is None: name = 'なし' if pid is None: pid = 51 userid = self.data.remote.user.from_refid(self.game, self.version, refid) defaultprofile = ValidatedDict({ 'name': name, 'pid': pid, 'settings': { 'flags': 223 # Default to turning on all optional folders }, }) self.put_profile(userid, defaultprofile) profile = self.get_profile(userid) return profile	def post_create_user(sender, instance, created, raw, **kwargs): if created and not raw: user = instance (user_profile, created) = UserProfile.objects.get_or_create( user=user )
Try to match country name with its code. Name of the city helps when country_name is "Korea".	def match_country_name_to_its_code(country_name, city=''): if country_name: country_name = country_name.upper().replace('.', '').strip() if country_to_iso_code.get(country_name): return country_to_iso_code.get(country_name) elif country_name == 'KOREA': if city.upper() in south_korean_cities: return 'KR' else: for c_code, spellings in countries_alternative_spellings.items(): for spelling in spellings: if country_name == spelling: return c_code return None	def find_code(city_name): try: code_2 = pycountry.subdivisions.lookup(city_name) code_3 = pycountry.countries.get(alpha_2=code_2.country_code) return code_3.alpha_3 except LookupError: print(f'Sorry, could not find a code for {city_name}', file=sys.stderr) return 'XXX'
takes a path to a folder and write all filenames recursively (files of all sub folders to)	def get_all_file_names(folderpath, out="../output.txt"): print("folder pathh: ", folderpath) file_list = os.listdir(folderpath) print("file_list:") print(file_list) with open(out, "a") as file2: for object_name in file_list: file2.write(str(object_name) + "\n") dir_path = os.path.join(folderpath, str(object_name)) if os.path.isdir( dir_path ): # Return True if path is an existing directory. This follows symbolic links, so both islink() and isdir() can be true for the same path.) print("Is dir", dir_path) get_all_file_names(dir_path, out)	def get_files_in_folder(folder): filenames = os.listdir(folder) # os.path.join combines paths while dealing with /s and \s appropriately full_filenames = [os.path.join(folder, filename) for filename in filenames] return full_filenames
콘크리트 슬래브 비용	우리의 콘크리트 슬래브 자재 추정에 따르면, 콘크리트 슬래브의 평균 최소 비용은 평방피트당 1.36달러이며, 최대 비용은 1.88달러입니다. 비교하자면, 시멘트 슬래브의 평방피트당 가격은 5.50달러입니다.	콘크리트 슬래브와 포장재의 비용 비교. 일반적으로 표준 콘크리트 슬래브는 대안보다 제곱피트당 비용이 낮습니다. 일반적으로 표준 콘크리트 슬래브 대신 포장석을 선택할 경우 10%-15% 더 지불하게 됩니다. 스탬프 콘크리트로 업그레이드하기로 결정하면, 대부분의 경우 포장석의 비용이 동일하거나 더 저렴할 가능성이 높습니다.
Processes a range of filenames and labels in the MPII dataset corresponding to the given thread index.	def _process_image_files_single_thread(coder, thread_index, ranges, mpii_dataset): if FLAGS.is_train: base_name = 'train' else: base_name = 'test' shards_per_thread = FLAGS.train_shards/FLAGS.num_threads shard_ranges = pose_util.get_n_ranges(ranges[thread_index][0], ranges[thread_index][1], shards_per_thread) for shard_index in range(len(shard_ranges)): tfrecord_index = int(thread_index*shards_per_thread + shard_index) tfrecord_filename = '{}{}.tfrecord'.format(base_name, tfrecord_index) tfrecord_filepath = os.path.join(FLAGS.train_dir, tfrecord_filename) options = tf.python_io.TFRecordOptions( compression_type=tf.python_io.TFRecordCompressionType.ZLIB) with tf.python_io.TFRecordWriter(path=tfrecord_filepath, options=options) as writer: shard_start = shard_ranges[shard_index][0] shard_end = shard_ranges[shard_index][1] for img_index in range(shard_start, shard_end): with tf.gfile.FastGFile(name=mpii_dataset.img_filenames[img_index], mode='rb') as f: image_jpeg = f.read() _write_example(coder, image_jpeg, mpii_dataset.people_in_imgs[img_index], writer)	def parallel_search_range(data, query_range, n_processor): results = [] pool = Pool(processes=n_processor) ### START CODE HERE ### # Perform data partitioning first partition_result=h_partition(data,n_processor) for query in range(query_range[0],query_range[1]+1): hash_value=s_hash(query,n_processor) working_dataset=partition_result[hash_value] indices=pool.apply(linear_search,[working_dataset,query]) for index in indices: results.append(working_dataset[index]) ### END CODE HERE ### return results

자유 여름의 목적은 무엇이었습니까?

자유 여름은 또한 전국 교회 협의회의 지원을 받았으며, 여름 동안 인권을 위한 의료 위원회의 자원봉사자들과 다양한 단체의 변호사들이 미시시피에서 활동했다. 자유 여름의 장기적인 목표는 미시시피의 권력 구조를 변화시키는 것이었다.

자유의 여름은 또한 전국 교회 협의회의 지원을 받았으며, 여름 동안 인권을 위한 의료 위원회의 자원봉사자들과 다양한 단체의 변호사들이 미시시피에서 활동했습니다. 자유의 여름의 장기적인 목표는 미시시피의 권력 구조를 변화시키는 것이었습니다.

End do_enable; called after state changes but before command acknowledged. This method connects to the HVAC server.

async def end_enable(self, id_data: salobj.BaseDdsDataType) -> None: if not self.connected: await self.connect() await super().end_enable(id_data)

def on_enable(self): self.i_err = 0

Function returns a list of creation datetimes for the files in the list of jpg files paths

def get_creation_times(list_of_jpg): list_of_creation_times = [] for jpg in list_of_jpg: try: image = Image.open(jpg) exif = image.getexif() creation_time = exif.get(36867) except: creation_time = None list_of_creation_times.append(creation_time) return list_of_creation_times

def image_timestamp_list(self) -> Dict[str, List[int]]: assert self.image_list is not None assert self._image_list is not None if self._image_timestamp_list is None: self._image_timestamp_list = {} for log in self.log_list: self._image_timestamp_list[log] = {} for camera in CAMERA_LIST: self._image_timestamp_list[log][camera] = [ int(x.split("/")[-1][:-4].split("_")[-1]) for x in self._image_list[log][camera] ] return self._image_timestamp_list[self.current_log]

Add a new snapshot node. It adds an entry in self.snapshotsCached and creates a new Checkbox object

def __addNewSnapshot__(self, snapshotNode): nodeID = snapshotNode.GetID() print("Added new node " + nodeID) name = snapshotNode.GetName() description = snapshotNode.GetSnapshotDescription() ckb = qt.QCheckBox() ckb.checked = True ckb.text = name ckb.toolTip = "%s. Uploaded to Picasa: NO" % description # Add the checkbox to the layout self.currentSnapshotsInnerLayout.addWidget(ckb) # Add a new snapshot node to the cached collection (Name, Description, Uploaded, Widget) self.snapshotsCached[nodeID] = [name, description, False, ckb] # Add an observer in case the node is modified (example: renamed) self.__addModifiedObserver__(snapshotNode) # Remove no items label if visible self.noItemsLabel.hide()

def push_snapshot(self):

Performs a commit A commit of known offsets for read partitions And subscription positions for untouched partitions

async def _do_commit(self): offsets = self._subscriptions.subscription \ .assignment.all_consumed_offsets() offsets.update(self._offsets) if offsets: await self._consumer.commit(offsets)

def _do_update_update(self, data, offset): assert IMutableUploadable.providedBy(data) assert self.is_mutable() # offset == self.get_size() is valid and means that we are # appending data to the file. assert offset <= self.get_size() segsize = self._version[3] # We'll need the segment that the data starts in, regardless of # what we'll do later. start_segment = offset // segsize # We only need the end segment if the data we append does not go # beyond the current end-of-file. end_segment = start_segment if offset + data.get_size() < self.get_size(): end_data = offset + data.get_size() # The last byte we touch is the end_data'th byte, which is actually # byte end_data - 1 because bytes are zero-indexed. end_data -= 1 end_segment = end_data // segsize self._start_segment = start_segment self._end_segment = end_segment # Now ask for the servermap to be updated in MODE_WRITE with # this update range. return self._update_servermap(update_range=(start_segment, end_segment))

Return a pandas dataframe Goes through all the events and tallies up the points of the students.

def parse_sheets(event_attendance, member_list): attendance = pd.DataFrame() #parse_bonus_points(attendance, member_list) attendance["Name:"] = member_list["First Name"].str.strip() + " " + member_list["Last Name"].str.strip() attendance["Total Spark Points:"] = 0 print(attendance) print(member_list) #Go through all events in the folder and check if the person attended. If yes, add points for index, member in attendance.iterrows(): #print(event_attendance) #print(member) name = str(member["Name:"].strip()).lower() valid = student_list.get(name, "NA") #Add a new student to the dictionary of student_list if not already there print(valid) if(valid == 'NA'): print("Added student " + name) student_list[name.lower()] = {'EID' : 0, 'Points' : 0} for event in event_attendance: eventdata = list(event.columns) event_name = eventdata[-1] #print(event_name) points_to_add = event.iat[0, len(eventdata)-1] attendance.at[index, event_name] = 0 #If the person is in the database and at the meeting, sum up each person's spark points and add to their total if check_attendance(member["Name:"].lower(), event): attendance.at[index, event_name] += points_to_add attendance.at[index, "Total Spark Points:"] += points_to_add #parse_shop() return attendance

def frame_info_to_df(obj_info_aggregated, frame_ind, camera_id, date_time): frame_df = pd.DataFrame(obj_info_aggregated, columns=[ 'obj_bounds', 'obj_classification', 'confidence']) frame_df["frame_id"] = frame_ind frame_df["camera_id"] = camera_id frame_df["video_upload_datetime"] = date_time return frame_df

아드레랄이 인간에게 미칠 수 있는 영향은 무엇인가?

아드레랄은 암페타민으로, 주의력 결핍 과다 행동 장애(ADHD)와 같은 장애를 치료하는 데 사용되는 중추 신경계 자극제입니다. 미국에서 일반적으로 사용되고 처방되는 암페타민에는 덱스트로암페타민이 포함되어 있습니다. 아드레랄은 암페타민과 덱스트로암페타민의 조합으로, ADHD와 기면증 치료에 널리 처방되는 의약품입니다. 아드레랄이 탈모를 유발합니까? 그렇다면 어떻게 유발합니까? 일반적으로 암페타민은 인체에서 잘 견디지만 일부 부작용이 있을 수 있습니다. 장기간 사용 및 중독 시 부작용이 훨씬 더 커지며, 여기에는 모발이 가늘어지거나 탈모가 포함됩니다. 탈모는 일반적으로 두피 전반에 걸쳐 퍼져 있으며 특정한 한 지역에만 집중되지 않습니다.

애드레랄에는 인간 성장 호르몬이 포함되어 있습니까? 애드레랄과 인간 성장 호르몬을 함께 복용할 수 있습니까? Treato에서 애드레랄과 인간 성장 호르몬에 대한 5가지 논의 내 북마크

전설, 속, 인어, 대부분, 사람, 존재, 무섭다

전설 속 인어는 대부분 죄 없는 사람을 해치는 무서운 존재이다.

옛날 다과상 차림은 녹차, 무지개떡, 밤다식, 생란, 율란, 조란 등이다.

Retrieves the pixel value from image Will keep requested pixel values within the bounds of the image

def get_pixel(image, x, y): y = y*image['width'] #Necessary to multiply by width for correct indexing in a list if x < 0: x = 0 if y < 0: y = 0 if x > image['width']-1: x = image['width']-1 if y > (image['height']-1)*image['width']: y = (image['height']-1)*image['width'] return image['pixels'][x+y]

def get_input(self, idx): img_filename = os.path.join( self.data_dir, self._input_array[idx]) x = Image.open(img_filename).convert('RGB') return x

Loads a specific dataset file from the csv. Split refers to the EMNIST split in the dataset.

def load_split(self, split, stage): if not split in self.splits: print(split, "is not a valid EMNIST split") return if not stage in self.stages: print(stage, "is not a valid stage") return csv_filename = self.data_folder + "/emnist-" + split + "-" + stage + ".csv" print("Loading", csv_filename) data_frame = pd.read_csv(csv_filename, header=None, dtype=np.int8) tensor_x = torch.Tensor(data_frame.iloc[:,1:].values.reshape((-1, 1, 28, 28))).float() # Load the images tensor_y = torch.Tensor(data_frame.iloc[:,0].values).long() # Load the labels return torch.utils.data.TensorDataset(tensor_x, tensor_y)

def load_data(self): data_frame = pd.read_csv(self.URL, encoding='ISO-8859-1') data_frame = data_frame[['cont_africa', 'rugged', 'rgdppc_2000']] data_frame.rgdppc_2000 = np.log(data_frame.rgdppc_2000) data_frame = data_frame[np.isfinite(data_frame.rgdppc_2000)] datasets = [] for flag in [0, 1]: split = data_frame[data_frame.cont_africa == flag] x, y = split.rugged.to_numpy(), split.rgdppc_2000.to_numpy() datasets.append([x, y]) return datasets

Create a new variable in the model, annotated with the given term, and in the given units.

def _create_annotated_variable(self, prefixed_name, units): #1903 TODO: Be more careful to create unique local names and ids prefix, local_name = prefixed_name.split(':') var = self.add_variable(self._get_protocol_component(), local_name, units, id=prefix + '_' + local_name) var.add_rdf_annotation(('bqbiol:is', NSS['bqbiol']), (prefixed_name, self._protocol_namespaces[prefix])) return var

def add_term(self, term, cursor=None, loci_cursor=None): if not cursor: cur = self.m80.db.cursor() cur.execute("BEGIN TRANSACTION") else: cur = cursor if not loci_cursor: lcur = self.loci.m80.db.cursor() lcur.execute("BEGIN TRANSACTION") else: lcur = loci_cursor # Add the term id and description cur.execute( """ INSERT OR ABORT INTO terms (name, desc) VALUES (?, ?)""", (term.name, term.desc), ) (TID,) = cur.execute("SELECT last_insert_rowid()").fetchone() if TID is None: # pragma: no cover # I dont know when this would happen without another exception being thrown raise ValueError(f"{term} was not assigned a valid TID!") for key, val in term.attrs.items(): cur.executemany(""" INSERT INTO term_attrs (TID, key, val) VALUES (?,?,?) """, ((TID,key,xval) for xval in val) ) # separate the new loci from the existing loci new_LIDs = [] existing_LIDs = [] for l in term.loci: try: existing_LIDs.append(self.loci._get_LID(l)) except MissingLocusError: new_LIDs.append(self.loci.add_locus(l, cur=lcur)) for LID in new_LIDs + existing_LIDs: cur.execute( """ INSERT INTO term_loci (TID,LID) VALUES (?,?) """, (TID, LID), ) if not cursor: cur.execute("END TRANSACTION")

Attaches to the gdbserver, running locally or portforwarded. If |remote_address| is set, it is used for ssh.

def _attach_bare_metal_gdb( remote_address, plugin_pid, ssh_options, nacl_helper_nonsfi_path, gdb_type): gdb_port = _get_bare_metal_gdb_port(plugin_pid) # Before launching 'gdb', we wait for that the target port is opened. _wait_by_busy_loop( lambda: _is_remote_port_open(_LOCAL_HOST, gdb_port)) gdb_args = [] if nacl_helper_nonsfi_path: gdb_args.append(nacl_helper_nonsfi_path) gdb_args.extend([ '-ex', 'target remote %s:%d' % (_LOCAL_HOST, gdb_port)]) gdb_args.extend(get_gdb_python_init_args()) library_path = os.path.abspath(build_common.get_load_library_path()) gdb_args.extend(get_gdb_python_script_init_args( 'bare_metal_support', arc_nexe=os.path.join( library_path, os.path.basename(build_common.get_runtime_main_nexe())), library_path=library_path, runnable_ld_path=os.path.join(library_path, 'runnable-ld.so'), lock_file=os.path.join(_BARE_METAL_GDB_LOCK_DIR, str(plugin_pid)), remote_address=remote_address, ssh_options=ssh_options)) gdb_args.extend(['-ex', r'echo To start: c or cont\n']) _launch_plugin_gdb(gdb_args, gdb_type)

def create_server_socket(self, local_address, peer, remote_address): self.server_sockets[local_address] = server_socket(self, local_address, peer, remote_address) self.server_sockets[local_address].run_thread.start()

호주는 임시직 시간제 공무원에게 본봉 외의 보수를 어떻게 주고 있지

3) 호주 호주의 공무원 임용은 정규직 전일제, 정규직 시간제 공무원, 임시직 전일제, 임시직 시간제 등 4가지로 분류된다. 전일제는 주 35시간 이상, 시간제는 주 35시간 미만 근무하는 것을 원칙으로 하며, 정규직 시간제 공무원의 경우 급여, 수당, 복지후생, 휴가 등 정규직 전일제공무원과 동등하다. 주당근무시간이 적으므로 급여나 수당 등이 전일제에 비해 적다. 임시직 시간제공무원의 경우 다른 정규직(전일제, 시간제 포함) 공무원과 임시직 전일제공무원의 임금, 수당, 휴가, 공휴일 규정이 적용되지 않는다. 기본급 이외의 수당이 지급될 경우 기본급의 15% 내외로 지급된다. 전체 공무원의 14%가 시간제공무원인 것으로 나타나고 있다.

□ 또한 고객으로부터 보수를 수취할 때에도 자문서비스를 제공하기 이전에 보상구조를 명시하도록 하고 이를 바탕으로 고객과 협상하여 자문보수를 결정하도록 함. ○ 영국의 경우 services and costs disclosure document나 combined initial disclosure document 중 적절한 것을 선택하여 서비스 제공이전에 고객에게 제시하도록 하고 있음. ○ 또한 영국은 총자문비용 공시에 대한 준칙을 적합성 보고서에 제공하도록 규제하고 있음. ○ 고객에게 제시한 보상구조 외의 여타 비용을 부과할 수 없으며 보상구조를 설명하는 내용에 거짓이 없어야 한다는 점도 규정 ○ 호주의 경우에도 수수료를 포함한 보수나 금전적 이익에 대한 정보 등을 Financial service guides(고객이 자문업자를 선택할 때 제공받는 자료), Statement of Advice(자문이 제공될 때 제공 받는 자료)등에 공시하도록 함. □ 나아가 유지관리와 관련된 보수의 경우, 자문업자가 서비스는 제대로 제공하지 않으면서 관련 보수만을 수취하는 경우가 발생하지 않도록 관련 내용을 명확히 공시하고 설명하도록 규정함. ○ 영국의 경우 유지관리 관련 보수(On going fee)를 상시적으로 수취하려면 고객에게 제공되는 서비스의 세부내역과 관련 수수료를 매칭하여 알려주고 만약 고객이 서비스를 중도에 취소하길 원한다면 지불을 중단할 수 있는 방법도 알려주도록 규제함. ○ 또한 유지관리관련 보수가 운용펀드의 일정 비율로 계산하여 수취하는 경우에는 펀드금액이 증가함에 따라 관련 지불금액 역시증가할 수 있다는 점을 고객에게 명시적으로 알려주도록 함. ○ 호주의 경우에도 영국과 유사하게 제공받는 서비스의 종류를 명시하고 취소방법 등을 알려주도록 규제하고 있음.

Sort the book based on the price (highest to lowest) and then the timestamp (earliest to latest).

def sort_orders(self): self.orders = sorted(self.orders, key=attrgetter('timestamp')) self.orders = sorted(self.orders, key=attrgetter('price'), reverse=True) #self.orders = sorted(self.orders, key=lambda order: order.timestamp) #print('<><><> BOOK AFTER ADD ORDER <><><>') #self.show_book() # print the book # size of order book after order added self.total_size_post_order = self.check_size() # what's the prize of the book (up to target_price shares) after order self.total_potential_price_post_trade = self.check_total_price()

def sortByRating(self): try: self.items.sort(key=lambda x: float(x[3]), reverse=False) except: pass

기획재정부가 달걀류 8가지 항목에 관한 할당관세 개정안을 결정한 건 언제야

기재부는 계란류 8개 품목 3만6,000톤에 대한 할당관세 규정 개정안도 이날 의결했다.

하지만 개정안이 통과돼도 일러야 9월에나 시행할 수 있는 데다, 예산을 쥔 기획재정부의 강력한 반대가 여전히 걸림돌이다.

광전류 봉우리를 세 군데에서 관측할 수 있는 이유가 뭐야?

광전류 봉우리는 세 곳에서 관측할 수 있는데 그 이유는 $ \mathrm{CdGa}_{2} \mathrm{Se}_{4} $ 단결정 박막은 육방정계 구조로 성장되어 spin-orbit splitting과 non cubic crystalline field 의 동시효과에 의하여 band splitting 이 일어난 것으로 볼 수 있다.

광전류 스펙트럼의 측정 에서 에너지 갭에 해당되는 가전자대에서 전도대로 들뜬 전자들에 의한 광전류 봉우리들과 단파장대에서 가 전자대 splitting에 의한 광전류 봉우리들이 관측되었다.

유럽부양규약은 개인정보 보호의 이익을 어떤 방식으로 감안하였어

유럽부양규약은 한편으로는, 중앙당국이 마련해 둔 정보만을 제공하도록 하고, 다른 한편으로는 제공할 정보를 주소, 소득, 사용자, 계좌보유 여부 및 재산 등으로 열거하는 방식을 통하여 개인정보 보호의 이익을 고려하였다. 이 규약에 따라 독일은 외국의 부양집행권원에 기한 강제집행과 관련하여 ｢국제 부양청구권 행사에 관한법률｣ 제17조에 중앙당국의 정보청구권과 정보의무를 규정해 놓고 있다. 위 법제17조의 규정 내용은 중앙당국이 법적 연금보험기관에 특히 당시의 사용자에 관한 정보를 조회할 수 있도록 하고, 4대보험기관에 구직자의 노무제공 현황을 조회하도록 하며, 연방국세청에 국세기본법 제93b조 제1항의 계좌정보를 조회할 수 있도록 하고 있다. 여기에 자동차에 대한 정보까지 규정하고 있어 대외부양법 제17조의 규정은 민사소송법상의 재산조회제도와 유사하다.

2. 영국 ｢익명화 실천규약｣의 주요내용 □ 영국 정보보호위원회 ｢익명화 실천규약｣은 일종의 안내서이기 때문에, 그 자체가 법적인 강제력을 가지는 것은 아니지만, 이 실천규약에서 규정한 사항들을 준수했다는 사실을 정보보호위원회가 확인할 경우, 이는 추후 정보보호위원회가 개인정보 보호와 관련한 법 위반 사실에 대한 조사나 법집행을 할 경우 적극적으로 고려하게 된다는 점에서, 이 규약은 간접적인 영향력을 지니는 가이드라인의 특성을 지니고 있다고 평가할 수 있음 □ 이 실천규약은 개인정보의 이용에 있어 보호업무를 충실히 수행하는 과정에서 유발될 수 있는 위험을 관리하는 방식으로 익명화를 소개하고 있음 ○ 우선 이 규약이 어떤 것이며 왜 등장했고 법적인 지위가 어떠한지(제1장)를 설명하고, 익명화라는 것은 개인정보의 정의와 분리하기 어려운 존재임을 밝힌 후(제2장), 개인정보의 익명화가 개인정보 보호에 효과적이라는 점을 설명함(제3장) ○ 이를 바탕으로 익명화된 정보를 생산하거나 공개할 때에 언제든지 정보주체의 동의가 필요한 것은 아니라는 점(제4장)과 공간정보를 개인정보처럼 취급해야 할지를 다룬 후(제5장), 개인정보 보호법제에 따라서는 공개해도 되는 정보도 인권법 같은 기타 법령에 의해 공개하지 말아야 하는 때가 있음(제6장)을 밝히고 있음 ○ 또한 개인정보 보호를 위해서는 정보의 유형별로 달리 취급될 필요가 있으며(제7장), 정보보호를 위한 거버넌스가 중요하다는 점(제8장) 및 보호와 이용의 균형을 위한 연구목적상 개인정보 보호법제의 적용예외(제9장)에 대해 설명하고 있음

Add InvertdIndex doc_index of the document doc_id to the MultiDocument InvertedIndex (inverted), using doc_id as document identifier.

def inverted_index_add(inverted, doc_id, doc_index): for word, locations in doc_index.iteritems(): indices = inverted.setdefault(word, {}) indices[doc_id] = locations return inverted

def _act_index_exact(fieldname, doc, value, context): doc.add_term(fieldname, value, 0)

초기 단계 조치에 따라 향후 몇 개월간 국제사회의 대이란 제재가 일부 완화될 수 있어

우리나라에 대한 2012년 미국 국방수권법상 대이란제재 예외 지위 연장 3. 한편, ‘P5+1’ 국가들(유엔 안보리 상임이사국인 미, 러, 중, 영, 프 5개국 및 독일)과 이란이 11.24(일) 제네바에서 합의한 ‘초기 단계 조치’에는, 이란 측의 약속 준수를 조건으로 향후 6개월간 국제사회의 대이란 제재가 일부 완화될 수 있다고 되어 있다. ㅇ 따라서, 앞으로의 이란산 원유 수입 감축 문제 등 제재 완화와 관련한 내용은 향후 제반 상황에 따라 구체화되어 갈 것으로 보며, 정부는 그 과정에서 관련 국가들과 필요한 협의를 해 나갈 예정이다. ※ 다만, 이번 제네바 합의에도 불구하고, 미국의「2013년 국방수권법」에 포함된 이란자유및반확산법(IFCA: Iran Freedom and Counterproliferation Act) 및 2010년 통합이란제재법(CISADA: Comprehensive Iran Sanctions, Accountability and Divestment Act) 등 다른 미국 법에 따른 대이란 제재는 지속 적용되므로 유의 필요 4. 우리 정부는 국제사회의 책임을 다하는 일원으로서 이란핵 문제의 평화적 해결을 위한 노력에 계속해서 적극 동참할 예정이며, 이러한 과정에서 우리 기업들이 불필요한 피해를 입지 않도록 앞으로도 최대한의 노력을 기울여 나갈 것이다.

글로벌 석유시장 변화를 원유수입다변화 기회로 3. 최근 석유시장 변화 및 대응 [ 이란제재 해제는 도입선 다변화의 기회 ] □ 전문가들은 내년도 상반기 이란 경제제재 해제로 이란산 원유가 시장에 공급될 경우 유가하락에 영향을 줄 것으로 전망 ㅇ 오랜 제재기간으로 이란 석유공급이 단기간내 제재전 수준으로 회복되기는 쉽지 않으나, 2016년에 50만～100만B/d 규모의 석유 공급이 가능하고, 3,000만B~6,000만B 규모의 해상재고를 보유하고 있어 향후 유가 하락요인으로 작용할 것으로 전망 * 이란제재 해제로 유가 추가하락을 전망하는 견해, 이미 유가에 선반영되어 있다는 견해가 있어 해제시 유가하락 규모에는 불확실성이 존재 □ 정유업계는 이란제재 해제시, 제재전 수준으로 이란 원유수입을 늘릴 것으로 전망 ㅇ 현재 이란산 원유수입은 제재 전과 비교하여 절반 수준으로 감소한 상황으로, 향후 컨덴세이트를 중심으로 이란원유에 대한 수요 증가 전망

Method is defined by the implemented data loaders to yield the sample indexes. Only used in data_generator.

def sample_index_generator(self): raise NotImplementedError

def get_sample(self, dataset, sample_idx): pass

check if loop brackets are balanced. if not exit assume the program was already sanitized from comments

def check_valid(program): balance = 0 for c in program: if c == '[': balance += 1 elif c == ']': balance -= 1 if balance < 0: print("\nERROR: Loop brackets not balanced", file=sys.stderr, flush=True) exit(-1) if balance > 0: print("\nERROR: Loop bracket not balanced, not enough closing", file=sys.stderr, flush=True) exit(-1)

def is_balanced(string: str) -> bool: open_brackets = {'(', '{', '['} close_brackets = {')', '}', ']'} bracket_pairs = { '}': '{', ')': '(', ']': '[' } stack = [] for bracket in string: if bracket in open_brackets: stack.append(bracket) elif bracket in close_brackets: if len(stack) and bracket_pairs[bracket] == stack[-1]: stack.pop() else: return False if not len(stack): return True return False

Return Relay vars from input shapes and create entries based on expected graph inputs to allow translation

def _get_relay_input_vars(graph, input_infos, prelude, is_module=True, default_dtype="float32"): graph_inputs = list(graph.inputs()) if is_module: # a module has "self" as first input, which we do not need/want graph_inputs = graph_inputs[1:] if not isinstance(input_infos, list): msg = "Graph inputs input_infos should be a list" raise RuntimeError(msg) if len(graph_inputs) != len(input_infos): msg = f"PyTorch has {len(graph_inputs)} inputs and input_infos lists {len(input_infos)}." raise RuntimeError(msg) def get_relay_ty(ishape, itype, pt_type): if pt_type.kind() == "TensorType": if not (_is_int_seq(ishape) or len(ishape) == 0): msg = "Shape for Tensors must be lists of ints" raise RuntimeError(msg) if (pt_type.dim() is not None and pt_type.dim() != len(ishape)) or ( pt_type.sizes() is not None and any([s1 != s2 for s1, s2 in zip(pt_type.sizes(), ishape)]) ): msg = "Shapes of input list and information in the graph do not match" raise RuntimeError(msg) if len(ishape) > 1 and any(dim <= 0 for dim in ishape[1:]): msg = ( "Expected input's non-batch dimensions to have positive length, " f"but input has a shape of {pt_type.sizes()}" ) raise RuntimeError(msg) pt_dtype = pt_type.scalarType() if not pt_dtype and itype: pt_dtype = itype dtype = _convert_data_type(pt_dtype, default_dtype=default_dtype) return TensorType(ishape, dtype) elif pt_type.kind() == "TupleType": if not isinstance(ishape, tuple): msg = "Shapes for tuples must be tuples" raise RuntimeError(msg) return TupleType( [get_relay_ty(elem, itype, pt_t) for elem, pt_t in zip(ishape, pt_type.elements())] ) elif pt_type.kind() == "ListType": if not isinstance(ishape, list): msg = "Shapes for lists must be lists" raise RuntimeError(msg) pt_elemtype = pt_type.getElementType() elem_tys = [get_relay_ty(s, itype, pt_elemtype) for s in ishape] if len(elem_tys) > 0 and not all(map(lambda ty: ty == elem_tys[0], elem_tys)): msg = "List elements need have identical types" raise RuntimeError(msg) rlist, _, _ = prelude.mod.get_type("List") return rlist(elem_tys[0]) elif pt_type.kind() == "OptionalType": # we do not support None yet, so we fill in the type return get_relay_ty(ishape, itype, pt_type.getElementType()) # TODO: scalar inputs raise NotImplementedError("unsupported input type") input_vars = {} new_input_infos = [] for num, inp in enumerate(input_infos): if not isinstance(inp, tuple): msg = f"Graph input {num} is not a tuple" raise RuntimeError(msg) if len(inp) != 2 or not isinstance(inp[0], str): msg = ( f"Graph input {inp} is not valid," f" expected ('name', shape) or ('name', (shape, dtype))" ) raise RuntimeError(msg) if not isinstance(inp[1], tuple) or len(inp[1]) == 0 or not isinstance(inp[1][-1], str): new_input_infos.append((inp[0], (inp[1], default_dtype))) else: new_input_infos.append(inp) input_types = [ (name, get_relay_ty(info[0], info[1], gi.type())) for (name, info), gi in zip(new_input_infos, graph_inputs) ] ir_inputs = [i.debugName() for i in graph_inputs] for ir_input, (name, itype) in zip(ir_inputs, input_types): inp = _expr.var(name, type_annotation=itype) # Translate from graph input to user input name input_vars[ir_input] = inp return input_vars

def parseInputs(): # Import past year's data data = {} # {year: df} # df row indices are months 0-11. colums are zones Z1-Z7 # values are energy consumption in that month in that zone, in GWh for year in const.DATA_YEARS: data[year] = pd.read_csv(f'{path}/{const.DATA_DIR}/NBTrend20{year}.csv', names=const.ZONES) # Import Incentive Rates incentiveRates = pd.read_csv(f'{path}/{const.INFO_DIR}/IncentiveRates.csv') emissionTax, nonEmissiveIncentive = incentiveRates.columns # $/kWh # Import Penalty Values penaltyValues = pd.read_csv(f'{path}/{const.INFO_DIR}/PenaltyValues.csv', names=const.PENALTY_ZONES) # Import Plant Production Rates plantProductionRates = pd.read_csv(f'{path}/{const.INFO_DIR}/PlantProductionRates.csv', names=const.PLANT_TYPES) return data, emissionTax, nonEmissiveIncentive, penaltyValues, plantProductionRates

This function creates a figure (chart) that is a Sankey Chart for the neighborhood that is input

def createSankeyChart(nbd): nbd_col = ( "neighbourhood_group_cleansed" if nbd == "All" else "neighbourhood_cleansed" ) if nbd != "All": three_proptype_df = rental_df[ rental_df["neighbourhood_group_cleansed"] == nbd ].copy() else: three_proptype_df = rental_df.copy() three_proptype_df = three_proptype_df[[nbd_col, "property_type_class"]].copy() # Limit types of property to House, Private Room and Shared Room three_proptype_df = three_proptype_df[ three_proptype_df["property_type_class"].str.contains( "House|Private Room|Shared Room|Condominium|Seviced apartment|Apartment|Townhouse" ) ] # we are not interested in Houseboats in the Sankey chart three_proptype_df = three_proptype_df[ ~three_proptype_df["property_type_class"].str.contains("Houseboat") ] label_list = three_proptype_df[nbd_col].unique().tolist() label_list.sort() label_list += three_proptype_df["property_type_class"].unique().tolist() # Create a new column count_listings with number of listings per neighborhood/neighborhood group and propert type sankey_df = three_proptype_df.groupby([nbd_col, "property_type_class"]).agg( count_listings=("property_type_class", "count") ) sankey_df = sankey_df.reset_index() # Create an dictionary of the indices of the nodes we are going to link (the sankey cchart links are created between these indices) label_idx_dict = {} for idx, label in enumerate(label_list): label_idx_dict[label] = idx # Use the dictionary to map the nodes to the indizes in the dataframe sankey_df["nbd_idx"] = sankey_df[nbd_col].map(label_idx_dict) sankey_df["prop_idx"] = sankey_df["property_type_class"].map(label_idx_dict) color_list = full_color_list[: len(three_proptype_df[nbd_col].unique().tolist())] group_color = dict(zip(list(sankey_df.groupby(nbd_col).groups.keys()), color_list,)) sankey_df["color_link"] = sankey_df[nbd_col].map(group_color) source = sankey_df["nbd_idx"].tolist() target = sankey_df["prop_idx"].tolist() values = sankey_df["count_listings"].tolist() # There are as many colors as nodes = 17 + 3 if nbd == "All": color_node = full_color_list + ["#befdb7", "#1B03A3", "#FEFCD7"] else: color_node = full_color_list[: len(label_list)] # For every neighborhood we use the same color for the link color_link = sankey_df["color_link"].tolist() fig = go.Figure( data=[ go.Sankey( node=dict( pad=15, thickness=20, line=dict(color="black", width=0.5), label=label_list, color=color_node, customdata=label_list, hovertemplate="%{customdata} has %{value} listings<extra></extra>", ), link=dict( source=source, target=target, value=values, color=color_link, hovertemplate="Link from %{source.customdata}<br />" + "to %{target.customdata}<br />has %{value} listings<extra></extra>", ), ) ] ) fig.update_layout( title_text="Available houses and rooms", font_size=12, title_font_color=dashboard_colors["medium-blue-grey"], font=dict(size=12, color=dashboard_colors["medium-blue-grey"]), ) # Set the theme fig.layout.template = "custom_dark" return fig

def show_custom_graph(self): pass

야외 캐노피/파티오의 비용은 얼마인가요?

일반적인 주택의 일반적인 창문에 대한 차양은 크기에 따라 300달러에서 700달러의 비용이 들 것입니다. 여기에는 프레임과 수동 리트랙션 메커니즘, 조립 하드웨어 및 설치 브래킷이 포함됩니다. 비리트랙션 금속 차양은 사용하기로 결정한 금속에 따라 500달러에서 800달러의 비용이 들 수 있습니다. 곰팡이 방지 처리를 적용하면 비용을 절감할 수 있으며, 변색 제거를 위한 청소 비용은 40달러입니다. 파티오용 모터화된 리트랙션 차양은 2,500달러에서 3,500달러의 비용이 들 수 있습니다.

패브릭 차양의 비용은 얼마인가요? 지역 파티오 및 경로 계약자에게 무료 견적을 받으세요. 야외 생활 공간에서 보내는 시간을 극대화하기 위해 그늘을 추가하는 것은 여름의 더위 속에서 무시되는 파티오와 오락에 적합한 분주한 파티오의 차이를 만들 수 있습니다.

Displays a text on the frame with a shadow behind it for better visualization on any background

def text_on_frame(frame, text, position, thickness, font_size=1, text_color=(255, 255, 255), shadow_color=(128, 128, 128), font_style=cv2.FONT_HERSHEY_SIMPLEX, line_style=cv2.LINE_AA): cv2.putText(frame, text, position, font_style, font_size, shadow_color, thickness+1, line_style) cv2.putText(frame, text, position, font_style, font_size, text_color, thickness, line_style)

def render_text(self, text, color, bg=None): return self.font.render(text, True, color, bg) # type: pygame.SurfaceType

Return the image from the input ``images`` list that has the largest overlap with the ``refimage`` image.

def max_overlap_image(refimage, images, enforce_user_order): if len(images) < 1: return None if enforce_user_order: # revert to old tweakreg behavior return images.pop(0) area = [refimage.intersection_area(im) for im in images] idx = np.argmax(area) return images.pop(idx)

def get_images_id_from_database(db, tags, img_type, use_count, limit): # First find intersection of each tag index in the databases all_tags_list = [] for tag in tags: coll = db[tag] raw_result = coll.find({}) image = [image['_id'] for image in list(raw_result)] result = db.images.find( {"_id" : {"$in" : image}, "img_type": img_type, "use_count": {"$gt": use_count}}, {"_id": 1}) images = [str(image['_id']) for image in list(result)] all_tags_list.append(images) id_list = set(all_tags_list[0]).intersection(*all_tags_list[1:]) # Second, check whether we have to fetch more images from default image pool if len(id_list) >= limit: print("Get images from index!") images_list = id_list[:limit] else: print("Not enough images from index!") print("Try to find more in the default image pool!") coll = db['images'] # Then to find other images from the default image pool all_tags_list = [] for tag in tags: tag_str = 'tags.%s' % tag result = coll.find( {tag_str: {"$exists": True}, "img_type": img_type, "use_count": {"$gt": use_count}}, {"_id": 1}) images = [str(image['_id']) for image in list(result)] all_tags_list.append(images) images_list = list(set(all_tags_list[0]).intersection(*all_tags_list[1:])) if len(images_list) >= limit: images_list = images_list[:limit] return images_list[:limit]

평평한 기판이란 무엇인가?

유리 기판은 액정 텔레비전(LCD), 플라즈마 텔레비전(PDP), 노트북 디스플레이와 같은 평판 디스플레이(FPD)를 만드는 시트 유리입니다. 이 재료는 창유리에 사용되는 시트 유리와 다릅니다. 액정 디스플레이와 플라즈마 디스플레이 간에도 재료가 다릅니다.

특히 중요하고 뉴스 가치가 있는 것은 갤럭시 S6 엣지(및 갤럭시 노트 엣지)의 유연한 플라스틱 기판에서의 OLED 디스플레이 성능이 갤럭시 S6의 전통적인 평면 및 단단한 기판에서의 성능과 본질적으로 동일하다는 점입니다. 이는 500픽셀 이상 및 2560x1440 해상도에서도 마찬가지입니다.

Count `constraints` for part one. Lines where `char` occurs at least `low` and at most `high` times.

def part_one(constraints: t.List[Constraint]) -> int: n_valid = 0 for low, high, char, password in constraints: n_valid += low <= password.count(char) <= high return n_valid

def main(text, char_lower, char_upper, total_lower, total_upper): answer_char, answer_total = [], [] _ = [char_lower.append(i) for i in text if i not in char_lower and i.islower()] _ = [char_upper.append(i) for i in text if i not in char_upper and i.isupper()] char_lower, char_upper = sorted(char_lower), sorted(char_upper) _ = [total_lower.append(text.count(i)) for i in char_lower] _ = [total_upper.append(text.count(i)) for i in char_upper] _ = answer_char.extend(char_lower), answer_char.extend(char_upper) _ = answer_total.extend(total_lower), answer_total.extend(total_upper) for i in range(len(answer_char)): total1, total2 = answer_total[i] // 5, answer_total[i] % 5 print("%s : %s" % (answer_char[i], (("-----|" * total1 + "-" * total2).rstrip("|"))))

This view should return a list of all the enrollments organized for the currently authenticated user's group.

def get_queryset(self): user = self.request.user if user.is_superuser: return Enrollment.objects.all() return Enrollment.objects.filter(organizer__in=user.groups.all())

def _GetEntitiesInEntityGroup(self, entity_group): raise NotImplementedError

Integration test with a real consul agent. Start a service, register it, close it, verify it's deregistered.

async def test_integration(self, deregister): tags = ("foo", "bar") service_id = str(uuid.uuid4()) # allow for parallel tests con = _LocalConsulAgentClient(token=None) ca = ConsulAgent( name="test-metrics", service_id=service_id, tags=tags, deregister=deregister, ) try: server = await aio.web.start_http_server( addr="127.0.0.1", service_discovery=ca ) except aiohttp.ClientOSError: pytest.skip("Missing consul agent.") svc = (await con.get_services())[service_id] assert "test-metrics" == svc["Service"] assert sorted(tags) == sorted(svc["Tags"]) assert server.socket.addr == svc["Address"] assert server.socket.port == svc["Port"] await server.close() services = await con.get_services() if deregister: # Assert service is gone iff we are supposed to deregister. assert service_id not in services else: assert service_id in services # Clean up behind ourselves. resp = await con.deregister_service(service_id) assert 200 == resp.status

def test_service_status_on_daemon_with_pid(): mock_service_list = ( '{\n\t"LimitLoadToSessionType" = "System";\n\t"Label" =' ' "com.salt";\n\t"OnDemand" = false;\n\t"LastExitStatus" = 0;\n\t"PID" =' ' 218;\n\t"Program" = "/opt/salt";\n\t\t"--disable-keepalive";\n\t);\n};' ) salt_dict = { "service.list": MagicMock(return_value=mock_service_list), } with patch.dict(mac_service.__salt__, salt_dict): with patch.object(mac_service, "_launch_agent", lambda _: False): with patch.object(mac_service, "_get_service", lambda _: {"": ""}): with patch.object( mac_service, "_always_running_service", lambda _: True ): assert mac_service.status("com.salt") is True

Counts the number of trainable tf.Variables to get a rough idea of how complex this Model is

def count_num_trainable(self): self.num_trainable_variables = 0 for variable in tf.trainable_variables(): # shape is an array of tf.Dimension shape = variable.get_shape() variable_parameters = 1 for dim in shape: variable_parameters *= dim.value self.num_trainable_variables += variable_parameters return self.num_trainable_variables

def param_size(model: torch.nn.Module) -> int: return sum(v.numel() for name, v in model.named_parameters() if "auxiliary" not in name)

This method accesses the get all profiles endpoint which takes a token since the route is authenticated

def get_all_profiles(self, token): return self.client.get( "/api/profiles/", HTTP_AUTHORIZATION='Bearer ' + token, format="json" )

def callback(): app = _get_app() app.authorize_access_token() return redirect(url_for('.profile'))

Returns the luminance of a pixel, which indicates its subjective brightness. This implementation uses the NTSC formula.

def luminance(pixel): r = GImage.getRed(pixel) g = GImage.getGreen(pixel) b = GImage.getBlue(pixel) return round(0.299 * r + 0.587 * g + 0.114 * b)

def __call__(self, image: np.ndarray) -> np.ndarray: if self.mode == "luminance": lum = hdrpy.get_lumianance(image) factor = 1. / np.amax(lum) else: factor = 1. / np.amax(image) return multiply_scalar(image, factor)

Run queued jobs. Since we've already sent the jobs to the PBS job system, don't do anything.

def run_queued_jobs(self): pass

def execute_queue(self): self.legacy_queue_execution()

Test _check_cache_for_egg checks the cache for the egg, returns path if present locally, or None if not.

def test_03_check_cache_for_egg(self): # Cleanup on isle one! launcher = ZMQEggDriverProcess("DUMMY_VAL") self.assertEqual(launcher._get_remote_egg(EGG), "/tmp/%s" % EGG) self.assertEqual(launcher._check_cache_for_egg("NOT_FOUND_EGG"), None) self.assertEqual(launcher._check_cache_for_egg(EGG), "/tmp/%s" % EGG)

def get(cache_dir=CACHE_DIR): current_wall = os.path.join(cache_dir, "pyc") if os.path.isfile(current_wall): return read_file(current_wall)[0] return "None"

부탄은 지도에서 어디에 위치해 있습니까?

부탄 지도는 부탄이 대 히말라야 산맥의 동쪽에 위치한 내륙 국가임을 보여줍니다. 부탄은 북쪽으로는 중국과, 남쪽으로는 인도와 국제 경계를 공유하고 있습니다.

부탄 및 인접 국가의 상세 지도. 구글 맵스 부탄 위치 목록에 오신 것을 환영합니다. 구글 맵스 관광이 의미 있는 곳에 오신 것을 환영합니다! 종합적인 목적지 안내서와 함께 maplandia.com은 상세한 위성 이미지를 통해 부탄을 탐험할 수 있도록 하여, 그 어느 때보다 빠르고 쉽게 가능합니다.

더덕김치, 있다, 오징어무말랭이김치

그것의 종류로는 더덕김치, 오징어무말랭이김치 등이 있다.

이곳의 밥상은 김치와 우거짓국, 그리고 무말랭이 버무린 것뿐이었다.

1985년부터 1997년까지 대한양궁협회장은 정몽구 현대차그룹 회장이 맡았고 2005년부터 여태까지는 정의선 부회장이 맡고 있는 중이다.

1985년부터 1997년까지 대한양궁협회장은 정몽구 현대차그룹 회장이었고 2005년부터 지금까지는 정의선 부회장이다.

1983년부터 1985년까지 재임한 초대 양궁협회장은 정몽준 아산재단 이사장이었고 뒤이어 정몽구 회장이 네 번 회장이 되었다.

Remove slave(s) from and existing zone (multiroom). Zone must already exist and slaves array cannot be empty.

def remove_zone_slave(self, slaves): if not slaves: _LOGGER.warning("Unable to find slaves to remove") else: _LOGGER.info( "Removing slaves from zone with master %s", self._device.config.name ) # SoundTouch API seems to have a bug and won't remove slaves if there are # more than one in the payload. Therefore we have to loop over all slaves # and remove them individually for slave in slaves: # make sure to not try to remove the master (aka current device) if slave.entity_id != self.entity_id: self._device.remove_zone_slave([slave.device])

def get_redis_slave_nodes(): az = _get_aci_client() return [cntr for cntr in az.container_groups.list() if _REDIS_SLAVE_REGEX.match(cntr.name)]

Stitch a series of images into an animation. Currently supports animated gifs, other formats coming as needed.

def stitch_to_animation(images, outpath=None, duration=0.5, palettesize=256, verbose=True): # import imageio try: import imageio except ImportError: raise ImportError( 'WrightTools.artists.stitch_to_animation requires imageio - https://imageio.github.io/') # parse filename if outpath is None: outpath = os.path.splitext(images[0])[0] + '.gif' # write try: t = wt_kit.Timer(verbose=False) with t, imageio.get_writer(outpath, mode='I', duration=duration, palettesize=palettesize) as writer: for p in images: image = imageio.imread(p) writer.append_data(image) except BaseException: print('Error: {0}'.format(sys.exc_info()[0])) return None # finish if verbose: interval = np.round(t.interval, 2) print('gif generated in {0} seconds - saved at {1}'.format(interval, outpath)) return outpath

def dream_seq(self): for i, path in enumerate(self.img_list[self.config["start_position"] :]): if i == 0: img1 = Image.open(path) d_img = self.deep_dream( self.transform(img1), self.model, i, seq="first" ) self.save_img(d_img, "", i) d_img = convert(d_img) flow_iter = 0 # the iterations needs to be reduced self.config["num_iterations"] -= 5 if i > 0: img2 = Image.open(path) feature_img, background_masked = self.get_opflow_image( img1, d_img, img2 ) feature_img = np.clip(feature_img, 0, 255) background_masked[background_masked > 0] = 1 - (flow_iter * 0.1) # 0.5 background_masked[background_masked == 0] = flow_iter * 0.1 d_img = self.deep_dream( self.transform(np.uint8(feature_img)), self.model, i, seq="first", mask=background_masked, ) # change position img1 = img2 self.save_img(d_img, "", i) d_img = convert(d_img) flow_iter += 1 flow_iter = 0 if flow_iter > 5 else flow_iter

Recives OCR text, extracts product. Text could contain garbage or wrong reads. >>> extract_product_from_text(''' ... d J

def extract_product_from_text(text): def extract(pattern): return extract_ocr_pattern(pattern, text) return { 'VENDORID': 1, 'VENDOR': 'example', 'ITEMNO': extract(r'ITEM ?ID(.*)DESC'), 'DESCRIPTION': extract(r'DESC(.*)UPC'), 'UPC': extract(r'UPC ?NO(.*)WEIGHT'), 'COST': extract(r'PRICE(.*?)\n'), }

def extract_text(self, input_file): logging.info("Extracting text from file " + input_file) try: tree = etree.parse(input_file) except etree.XMLSyntaxError: logging.error("XML syntaxerror in file " + input_file) if self.force: return else: sys.exit(-1) root = tree.getroot() for element in root.iter(): try: self.extract_element_info(element, input_file) except KeyError: pass

대마초가 소변에 얼마나 오래 남아 있는지

소변은 마리화나를 단 한 번 사용한 후 최대 8일 동안 THC 대사산물인 THC-COOH의 존재를 나타냅니다. 소변 검사 정확도는 약 일주일 후 감소하지만, 많은 빈번하거나 과도한 마리화나 사용자들은 각각 최대 15일 및 90일 동안 양성 반응을 보일 수 있습니다.

THC가 소변에 얼마나 오래 남아 있는지는 개인에 따라 다릅니다. 체중과 이전의 마리화나 노출은 테트라하이드로카나비놀(Tetrahydrocannabinol)이 체내에 얼마나 오래 남아 있을 수 있는지를 결정하는 주요 요인 중 일부입니다.

Setter method to set the next turn. Calls get turn and sets opposite player to next turn.

def set_next_turn(self): if self.get_turn() == 'B': self._turn = 'W' else: self._turn = 'B'

def set_next(self,next_class: 'Class') -> None: self.next = next_class

Return the second element of the given list. If the list has no second element, return None.

def select_second(L): if len(L)<2: return None return L[1]

def _return_elem_or_list(self, args): return args[0] if len(args) == 1 else args

Clear only parameter values, not the list of managed parameters. All parameters will be set to None.

def clear_parameter_values(self): for param_name in self.managed_parameters: self.managed_parameters[param_name] = None

def unfreeze_parameters(self): self.are_parameters_frozen = False

참여자, 종이, 메시지, 남기다, 응원

모든 참여자는 주어진 종이에 응원의 메시지를 남긴다.

재주라는 것은 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기다.

애플 TV 엔터테인먼트 채널은 몇 개입니까?

2007년에 처음 출시된 이후, 애플 TV는 단일 방송 네트워크에서부터 거의 20개의 한국 TV 네트워크를 하나의 채널로 집계한 것까지, 약 50개의 "채널" 또는 선호하는 용어인 앱을 보유하고 있습니다.

호주 내 인도 TV 및 라디오 채널. 인도 드라마, 음악 및 코미디 쇼 등은 모든 인도인의 마음에 가깝습니다. 우리는 인도 TV 채널과 라디오를 통해 인도와 연결되어 있다고 느낍니다. 인도 엔터테인먼트와의 연결을 유지하기 위해 호주에서 인도 TV 채널 및 라디오를 얻는 방법에 대한 포괄적인 목록을 확인하십시오: 인도 TV 채널 얻기: Yupptv: 호주에서 YuppTV를 통해 제공되는 인도 TV 채널.

가면라이더 디케이드의 필살기가 뭐야

또한 컴플리트 폼 상태에서 다른 라이더를 소환한 뒤 이 카드를 사용하면, 디케이드는 라이드 북커를 활용해서 자신과 똑같이 움직이는, 소환된 라이더와 함께, 소환된 라이더의 최종 형태가 사용하는 필살기를 시전한다. 디케이드는 디멘션 킥 이라는 라이더 킥을 필살기로 사용한다. 라이드 북커 소드 모드에서는 적을 힘껏 베는 디멘션 슬래시 를 사용할 수 있다. 또한 건 모드에서는 적에게 강력한 에너지탄을 쏘는 디멘션 블래스트 를 사용할 수 있다. 각 필살기를 사용할 때마다 디케이드의 파이널 어택 라이드 카드를 형상화한 환영들이 적을 향해 전개된다. 파이널 가면라이더 단말 K-터치 는 터치(터치스크린)폰(휴대폰)의 일종으로, 가면라이더 디케이드의 강화 변신 장비이다. 네거비트의 세계(가면라이더 디케이드의 새로운 세계의 등장 인물#네거티브의 세계)에서 츠카사가 손에 넣었다.

유키 조지가 변신하는 라이더맨은 극장판에서 모든 라이더들이 나타날 때 같이 등장했지만, 변신하는 장면은 묘사되지 않았다. 유키 조지의 인간 모습은 각트가 연기했으며, "The Next Decade"에서도 연기했다. 대쇼커는 수많은 악의 결사가 집합한 거대한 악의 조직이다. 로고는 원래의 쇼커 로고에 디케이드를 상징하는 "DCD"가 추가된 형태이다. 사신 박사(가면라이더 디케이드의 등장 인물#히카리 에이지로), 아폴로 가이스트(가면라이더 디케이드의 등장 인물#아폴로 가이스트) 외 역대 가면라이더 시리즈의 악당과 괴인들이 모여 있다. 지옥대사는 가면라이더의 세계(가면라이더)에서 온, 쇼커(쇼커 (가면라이더))의 간부이다. 방울뱀 형태의 가라가란다라는 괴인으로 변신할 수 있다.

Public method to get the word at the current position. the word at that current position (string)

def getCurrentWord(self): line, index = self.getCursorPosition() return self.getWord(line, index)

def echoPreviousWord(self, obj, offset=None): try: text = obj.queryText() except NotImplementedError: return if not offset: offset = text.caretOffset - 1 if (offset < 0): return [char, startOffset, endOffset] = \ text.getTextAtOffset( \ offset, pyatspi.TEXT_BOUNDARY_CHAR) if not self.utilities.isWordDelimiter(char): return # OK - we seem to be cool so far. So...starting with what # should be the last character in the word (caretOffset - 2), # work our way to the beginning of the word, stopping when # we hit another word delimiter. # wordEndOffset = offset - 1 wordStartOffset = wordEndOffset while wordStartOffset >= 0: [char, startOffset, endOffset] = \ text.getTextAtOffset( \ wordStartOffset, pyatspi.TEXT_BOUNDARY_CHAR) if self.utilities.isWordDelimiter(char): break else: wordStartOffset -= 1 # If we came across a word delimiter before hitting any # text, we really don't have a previous word. # # Otherwise, get the word. Remember we stopped when we # hit a word delimiter, so the word really starts at # wordStartOffset + 1. getText also does not include # the character at wordEndOffset, so we need to adjust # for that, too. # if wordStartOffset == wordEndOffset: return else: word = self.utilities.\ substring(obj, wordStartOffset + 1, wordEndOffset + 1) if self.utilities.linkIndex(obj, wordStartOffset + 1) >= 0: voice = self.voices[settings.HYPERLINK_VOICE] elif word.decode("UTF-8").isupper(): voice = self.voices[settings.UPPERCASE_VOICE] else: voice = self.voices[settings.DEFAULT_VOICE] word = self.utilities.adjustForRepeats(word) speech.speak(word, voice)

Wraps an agent's program function and prints the inputs/outputs, so you can watch it in its environment.

def trace_agent(agent:'agent') -> 'agent': old_program = agent.program def new_program(percept): action = old_program(percept) print('{} perceives {} and does {}'.format(agent, percept, action)) return action agent.program = new_program return agent

def foo(args): output("Foo!") return 0

Returns the index ID of the column. The structure of the CSV is defined in the configuration.

def __get_column_id(element: str) -> Optional[int]: idx = 0 for col in config.csv_headers: if col == element: return idx else: idx += 1

def ts_id_col(self): return self._ts_id_col if self._ts_id_col else ["ts_col_1"]

Representative content for a taxon. Will throw an error if the file it needs does not exist

def representative_content_for_taxon(taxon): # TODO: What to do about test/train content? representative_content_path = RepresentativeContent.path_for_representative_content(taxon) if os.path.exists(representative_content_path) and os.path.isfile(representative_content_path): most_representative_content = pd.read_csv(representative_content_path, low_memory=False) return most_representative_content['combined_text'].to_list() else: raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), f"Representative content file for {taxon.unique_title()} has not been generated, should be at: {representative_content_path}")

def usage(): with open('./usage.txt') as file_obj: contents = file_obj.read() return contents

그린스보로의 날씨는 어떤가요?

노스캐롤라이나 날씨 > 그린스보로 날씨. 그린스보로, NC의 기후는 여름에 기온이 70도대에 이르는 따뜻한 날씨를 보이며, 겨울에는 기온이 30도대에 이르는 매우 추운 날씨를 보입니다.

그린스보로 날씨 평균 및 기후 그린스보로, 노스캐롤라이나. 월별 온도, 강수량 및 일조 시간. 강수량 데이터, 온도 및 정상값을 보여주는 기후 그래프. 평균 날씨 그린스보로, NC.

Tests that newly created story cells decompose into concept cells, matching the concepts appearing in the text.

def test_cells_concept_extraction(self): # verify that the expected concepts do not exist self.assertEquals(0, ConceptCell.objects.filter(name="EveryBlock").count(), "Expected that the concept EveryBlock does not exist in the test fixtures") self.assertEquals(0, ConceptCell.objects.filter(name="Glenn").count(), "Expected that the concept Glenn Ford does not exist in the test fixtures") # add agents self.society_cell.add_agent("Bill", "Bill", DATASOURCE_TYPE_TWITTER) self.society_cell.add_agent("Al", "Al", DATASOURCE_TYPE_TWITTER) # fetch agents query = AgentCell.objects.filter(user__user_name="Bill") self.assertTrue(query.count() > 0, "Agent wasn't created") bill = query[0] query = AgentCell.objects.filter(user__user_name="Al") self.assertTrue(query.count() > 0, "Agent wasn't created") al = query[0] # add stories al.add_read_story("RT @yahoo RE YQL, EveryBlock API: were working \w senator Glenn Ford on all the details", [bill.user]) self.society_cell.process() # look up the concepts: YQL, EveryBlock, Glenn Ford self.assertEquals(1, ConceptCell.objects.filter(name="EveryBlock").count(), "Expected that the concept EveryBlock would be extracted from the added story") self.assertEquals(1, ConceptCell.objects.filter(name="Glenn").count(), "Expected that the concept Glenn Ford would be extracted from the added story") # get the concepts everyblock = ConceptCell.objects.filter(name="EveryBlock")[0] glenn = ConceptCell.objects.filter(name="Glenn")[0] # test concept recipient self.assertTrue(everyblock.recipients.all().count() > 0, "Expected to find reciipients for the new concepts") self.assertEquals(al.user, everyblock.recipients.all()[0], "Expected to find a specific recipient of the concept") self.assertTrue(glenn.recipients.all().count() > 0, "Expected to find reciipients for the new concepts") self.assertEquals(al.user, glenn.recipients.all()[0], "Expected to find a specific recipient of the concept")

def test_trait_count_12(self): things = self.model_factory.create_batch(20, source_study_version__i_is_deprecated=False) table = self.table_class(things) row = table.rows[0] n_traits = 12 factories.SourceTraitFactory.create_batch( n_traits, source_dataset=row.record) # Remake the table, to update trait counts. table = self.table_class(things) row = table.rows[0] self.assertEqual(row.get_cell('trait_count'), '{:,}'.format(n_traits))

Given an m x n matrix zero the rows and columns that have a 0 in it.

def zero_rows_columns(matrix): rows = [] columns = [] for i in range(len(matrix)): for j in range(len(matrix[0])): if matrix[i][j] == 0: rows.append(i) columns.append(j) for i in range(len(matrix)): for j in range(len(matrix[0])): if i in rows or j in columns: matrix[i][j] = 0 return matrix

def find_empty(board): for i in range(len(board)): for j in range(len(board[0])): if board[i][j] == 0: return i, j return None

미국 공군 사관학교는 어디에 있습니까?

포브스 리스트. 프로필. 미국 공군 사관학교는 콜로라도 스프링스, CO에 위치한 학생 사관생들을 위한 군사 서비스 아카데미로, 공군 기지로도 기능합니다. 공군은 공학 프로그램으로 유명하며, 이 학교는 국가 안보 연구소와 협력하여 광범위한 연구 기회와 보조금을 제공합니다.

미국 공군 사관학교. 미국 공군 사관학교(USAFA 또는 공군 사관학교로도 알려짐)는 미국 공군의 장교 후보생을 위한 군사 학교입니다. 이 캠퍼스는 미국 서부 콜로라도에 위치하고 있으며, 엘파소 카운티의 콜로라도 스프링스 바로 북쪽에 있습니다.

Disable Intan impedance testing Make sure DAQ is running, e.g. by calling startStreaming_boardSamples(), before calling this function.

def disableZCheck(): """ cmdData_DACconfig = ((0x1 << 24) | (0xFF << 16) | (0b10000101 << 8) | 0) # clear register cmdData_DACchan = ((0x1 << 24) | (0xFF << 16) | (0b10000111 << 8) | 0) # clear register """ #### cmds = [] #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, cmdData_DACconfig)) cmds.append(_intanRegWrite(address=5, data=0)) #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, cmdData_DACchan)) cmds.append(_intanRegWrite(address=7, data=0)) #cmds.append(DC.reg_write(DC.MOD_DAQ, DC.DAQ_CHIP_CMD, 0)) # clear the CMD register cmds.append(_intanRegWrite(clear=True)) resps = _controlCmdWrapper(cmds)

def test_reportexclude(self): # default self.assertIsNone(self.settings.reportexclude) # turn things off options = random.randrange(1, 4) value = ''.join([random.choice('CDMSV') for option in xrange(options)]) self.settings.reportexclude = value self.assertEqual(' --reportexclude {0}'.format(value), str(self.settings)) # bad exclusion (number) with self.assertRaises(CameraobscuraError): self.settings.reportexclude = random.randrange(100) # invalid option with self.assertRaises(CameraobscuraError): self.settings.reportexclude = random.choice('ABEFGHIJKLNOP') return

마찰력이 강해져 원반이 엑스선을 방출할수 있게 뜨거워지면, 엑스선을 무엇으로 관찰 가능한가요?

블랙홀 강착을 일으키는 천체가 중성자별이나 블랙홀일 경우, 강착원반 안쪽의 가스는 밀집성 본체에 매우 가까워져 엄청난 고속으로 회전할 것이다. 그러면 마찰력이 너무 강해져서 원반이 전자기 복사(주로 엑스선)를 방출할 만큼 뜨거워진다. 이렇게 밝은 엑스선원들은 망원경으로 관측이 가능하다. 강착원반의 엑스선 방출은 지금까지 알려진 가장 에너지 효율이 높은 과정에 속한다. 항성 내부 핵융합이 질량의 0.7%를 에너지로 방출하는 반면, 강착원반은 질량의 40%를 복사 에너지로 방출시킨다. 많은 경우 강착원반은 밀집성의 양극 방향으로 분출되는 엄청난 에너지의 상대론적 제트를 수반한다. 이 제트가 만들어지는 과정은 현재로서 완전히 이해되지 못하고 있다.

블랙홀 찰스 토머스 볼튼, 루이스 웹스터(Louise Webster), 파울 무르딘(Paul Murdin)이 1972년에 최초의 강력한 블랙홀 후보 천체 백조자리 X-1를 이 방식으로 발견해냈다. 그러나 동반성이 블랙홀 후보보다 더 무거울 수 있기에 이 방법에는 다소의 불확실성이 남아 있다. 현재는 엑스선 쌍성계 중에서도 일시적 연엑스선(X-ray transients)으로 분류되는 계들에서 블랙홀 후보들이 보다 더 잘 발견된다. 이 종류의 쌍성계에서는 밀집성의 동반성의 질량이 상대적으로 작으며, 그 때문에 블랙홀의 질량을 보다 정확하게 추산할 수 있다. 또한 이들 계는 10 ~ 50년 동안 불과 수 개월 동안만 엑스선을 활발하게 방출한다. 엑스선 방출이 저조해지는 시기를 휴면기(quiescence)라 하며, 이 때 강착원반이 극도로 어두워져 동반성을 세밀하게 관측할 수 있게 된다. 이러한 블랙홀 후보 중 가장 적절한 예가 백조자리 V404이다.

Test that a ValueError gets raised when a required SignatureVerifyResponsePayload field is missing when encoding the struct.

def test_write_missing_validity_indicator(self): payload = signature_verify.SignatureVerifyResponsePayload( unique_identifier='49a1ca88-6bea-4fb2-b450-7e58802c3038' ) stream = utils.BytearrayStream() args = (stream, ) self.assertRaisesRegex( ValueError, "Payload is missing the validity indicator field.", payload.write, *args )

def test_some_missing_data(self, client): response = client.post( "/api/v1/register", data=json.dumps(some_missing), content_type='application/json;charset=utf-8') res_data = json.loads(response.get_data(as_text=True)) assert 'Bad Request' in res_data['status'] assert 'Missing data for required field.' in str(res_data['Message'])

Apply on a scalar field. If the argument is not a scalar field an error is raised.

def __call__(self, scalar_field): return self.v1(self.v2(scalar_field)) - self.v2(self.v1(scalar_field))

def alter_field(self, model, old_field, new_field, strict=False): # TODO : Logic to "upgrade" old data pass

solve_tsp solve the traveling salesman problem start with assignment model add cuts until there are no subcycles

def solve_tsp(V, c): # 部分巡回路除去製薬 def addcut(edges): G = nx.Graph() G.add_nodes_from(V) for (i, j) in edges: G.add_edge(i, j) Components = list(nx.connected_components(G)) if len(Components) == 1: return False for S in Components: model.addConstr(quicksum(x[i, j] for i in S for j in S if j > i) <= len(S) - 1) return True model = Model("tsp") x = {} for i in V: for j in V: x[i, j] = model.addVar(ub=1) model.update() for i in V: model.addConstr(quicksum(x[j, i] for j in V if j < i) + quicksum(x[i, j] for j in V if j > i) == 2) model.setObjective(quicksum(c[i, j] * x[i, j] for i in V for j in V if j > i), GRB.MINIMIZE) EPS = 1.e-6 while True: model.optimize() edges = [] for (i, j) in x: if x[i, j].X > EPS: edges.append((i, j)) if not addcut(edges): if model.IsMIP: break for (i, j) in x: x[i, j].VType = "B" model.update() return model.ObjVal, edges

def post_calc(self): # self.mfp = fcl.mean_free_path(self.solver_T, self.solver_p, # self.atmosphere.d) # self.Kn = self.mfp / self.spacecraft.L ## self.Re = fcl.KnReMa(self.atmosphere.k, Kn=self.Kn, ## Ma=self.Ma) # self.Re = fcl.Reynolds(self.solver_rho, self.V, self.spacecraft.L, # self.solver_mu) # Continuum: 0 < Kn < 0.001 # Slip: 0.001 <= Kn < 0.1 # Transition: 0.1 <= Kn < 10 # Free molecular: 10 < Kn self.regimes = placeholder() if len(np.argwhere(self.Kn > 10)) != 0: self.index_tran_freemol = np.argwhere(self.Kn > 10)[-1] self.regimes.free_molecular = np.argwhere(self.Kn >= 10) else: self.index_tran_freemol = None if len(np.argwhere(self.Kn > 0.1)) != 0: self.index_slip_tran = np.argwhere(self.Kn > 0.1)[-1] self.regimes.transition = np.argwhere((self.Kn < 10) & (self.Kn >= 0.1)) else: self.index_slip_tran = None if len(np.argwhere(self.Kn > 0.001)) != 0: self.index_cont_slip = np.argwhere(self.Kn > 0.001)[-1] self.regimes.slip = np.argwhere((self.Kn < 0.1) & (self.Kn >= 0.001)) else: self.index_cont_slip = None if len(np.argwhere((self.Kn > 0) & (self.Kn <= 0.001))) != 0: self.regimes.continuum = np.argwhere((self.Kn < 0.001) & (self.Kn >= 0)) else: self.index_cont_slip = None return [self.mfp, self.Kn, self.Re]

Get the auth time for the security context. Gets the auth time for the established security context.

def krb5_extract_authtime_from_sec_context( context: "SecurityContext", ) -> int:

def getServerTimeForOTP(self) -> datetime.datetime: # This method seems to be useless to generate the OTP(One Time Password), but I leave it there if not self.__connected: raise ConnectionError r = self.__s.get(f"{BASE_URL}/nvsecurityapi/rest/enrollments/time") httpTime = r.headers["Date"] time = datetime.datetime.strptime( httpTime, '%a, %d %b %Y %H:%M:%S GMT') return time

Shows ann error if the user specifies an overly complicated system that requires too much memory allocation.

def show_size_error(self): messagebox.showerror(title = 'Memory Error', message = 'The parameters ' + 'you have specified require too much memory to be ' + 'computed. Please decrease the simulation time ' + 'and/or the transport rates to rectify this issue.') self.frame.quit()

def test_memory_usage(self): manager = ApacheManager() # Make sure there are Apache workers alive that have handled a couple of requests. for i in range(10): manager.fetch_status_page(manager.text_status_url) assert sum(manager.memory_usage) > 0 # TODO Create a WSGI process group so we can perform a useful test here? assert isinstance(manager.wsgi_process_groups, dict)

Adds an occupant to its list of occupants to keep track of as well as the rlt

def add(self, o): self.__occupants.append(o[0]) self.__position_rlt[o[0]] = (o[1], o[2])

def increment_room_occupancy(room, occupancy_additional): with sqlite3.connect(database) as c: c.execute('''CREATE TABLE IF NOT EXISTS rooms (name text UNIQUE, capacity integer, occupancy integer, noiseLevel integer);''') validate_room(room) current_occupancy = c.execute('''SELECT occupancy FROM rooms WHERE name=?;''', (room,)).fetchone()[0] new_occupancy = current_occupancy + occupancy_additional c.execute('''UPDATE rooms SET occupancy=? WHERE name=?;''', (new_occupancy, room))

Writes output matches to a file in the subfolder "Matches". It supports any iterable as output matches.

def file_output(matches: list, output_file_name: str = 'matches.txt'): with open("test/Matches/" + output_file_name, 'w') as f: for match in matches: for event in match.events: f.write("%s\n" % event.payload) f.write("\n")

def write(afile, seqs): for s in seqs : writeseq(afile, s)

Return whether finding group list for a specified node is supported by the resolver (in optional namespace).

def has_node_groups(self, namespace=None): try: return bool(self._source(namespace).reverse_upcall) except GroupResolverSourceError: return False

def is_in_group(user, group_name): return user.groups.filter(name__exact=group_name).exists()

A callback method that is called when the desired properties of the devices device twin are updated.

def on_device_twin_desired_updated(self): return self._on_device_twin_desired_updated

def set_update_callback(self): pass

군청, 직원, 젊다, 상냥하다

군청의 젊은 직원이 유독 무척 상냥한 것 같다.

재주는 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기 등등 이다.

inherits the __init__ from Number if just normal number or uses new method if its a list.

def __init__(self, number=None): if type(number) != list: print("hei") super().__init__(float(number)) elif type(number) == list: self.number = [] for i in number: self.number.append(i) else: raise TypeError("number added inn does not fill any of the type categories ´int/float/list´")

def __new__(*args, **kwargs): # real signature unknown pass

Iteratively zoom in on the minimum position in an image until the deltapeak value is below `mindiff`

def iterative_zoom(image, mindiff=1., zoomshape=[10,10], return_zoomed=False, zoomstep=2, verbose=False, minmax=np.min, ploteach=False, return_center=True): image_zoom = image argminmax = np.argmin if "min" in minmax.__name__ else np.argmax zf = 1. # "zoom factor" initialized to 1 for the base shift measurement offset = np.array([0]*image.ndim,dtype='float') # center offset delta_image = (image_zoom - minmax(image_zoom)) xaxzoom = np.indices(image.shape) if ploteach: ii = 1 pl.figure(ii) pl.clf() pl.pcolor(np.arange(image.shape[0]+1)-0.5,np.arange(image.shape[1]+1)-0.5, image) minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) pl.plot(minpos[1],minpos[0],'wx') # check to make sure the smallest *nonzero* difference > mindiff while np.abs(delta_image[np.abs(delta_image)>0]).min() > mindiff: minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) center = xaxzoom[0][minpos],xaxzoom[1][minpos] offset = xaxzoom[0][minpos]-(image.shape[0]-1)/2,xaxzoom[1][minpos]-(image.shape[1]-1)/2 zf *= zoomstep xaxzoom, image_zoom = zoom.zoom_on_pixel(image, center, usfac=zf, outshape=zoomshape, return_xouts=True) delta_image = image_zoom-minmax(image_zoom) # base case: in case you can't do any better... # (at this point, you're all the way zoomed) if np.all(delta_image == 0): if verbose: print("Can't zoom any further. zf=%i" % zf) break if verbose: print(("Zoom factor %6i, center = %30s, offset=%30s, minpos=%30s, min|diff|=%15g" % (zf, ",".join(["%15g" % c for c in center]), ",".join(["%15g" % c for c in offset]), ",".join(["%5i" % c for c in minpos]), np.abs(delta_image[np.abs(delta_image)>0]).min() ))) if ploteach: ii += 1 pl.figure(ii) pl.clf() pl.pcolor(centers_to_edges(xaxzoom[1][0,:]),centers_to_edges(xaxzoom[0][:,0]),image_zoom) pl.contour(xaxzoom[1],xaxzoom[0],image_zoom-image_zoom.min(),levels=[1,5,15],cmap=pl.cm.gray) pl.plot(center[1],center[0],'wx') minpos = np.unravel_index(argminmax(image_zoom), image_zoom.shape) pl.plot(xaxzoom[1][minpos], xaxzoom[0][minpos], 'w+') pl.arrow(center[1],center[0],xaxzoom[1][minpos]-center[1],xaxzoom[0][minpos]-center[0],color='w', head_width=0.1/zf, linewidth=1./zf, length_includes_head=True) pl.figure(1) #pl.contour(xaxzoom[1],xaxzoom[0],image_zoom-image_zoom.min(),levels=[1,5,15],cmap=pl.cm.gray) pl.arrow(center[1],center[0],xaxzoom[1][minpos]-center[1],xaxzoom[0][minpos]-center[0],color='w', head_width=0.1/zf, linewidth=1./zf, length_includes_head=True) if return_center: result = center else: result = offset if return_zoomed: return image_zoom,zf,result else: return result

def initial_guess(cts, xmin, xmax, size_window_background_left, size_window_background_right): # Automatic finding peak parameters number_of_image = len(cts) # nbre of images in the scan add_x0 = 0 add_IM = 0 add_H = 0 add_A = 0 add_B = 0 for ii in range(number_of_image): number_of_pixel = len(cts[ii]) x = np.arange(0, number_of_pixel, 1) step = x[1] - x[0] # Obtaining and add x0, IM and H add_x0 += (xmin + list_manipulation.index(cts[ii][xmin:xmax], max(cts[ii][xmin:xmax]))) add_IM += max(cts[ii][xmin:xmax]) add_H += (trapeze_method(cts[ii][xmin:xmax], step) / max(cts[ii][xmin:xmax])) # Obtaining A and B background_left = cts[ii][xmin:xmin + size_window_background_left] background_right = cts[ii][xmax - size_window_background_right:xmax] left_point_value = np.mean(background_left) right_point_value = np.mean(background_right) left_point_absc = xmin + size_window_background_left / 2 right_point_absc = xmax - size_window_background_right / 2 B_temp = (left_point_value - right_point_value) / (left_point_absc - right_point_absc) A_temp = left_point_value - B_temp * left_point_absc add_A += A_temp add_B += B_temp x0 = add_x0 / number_of_image IM = add_IM / number_of_image H = add_H / number_of_image A = add_A / number_of_image B = add_B / number_of_image return x0, IM, H, A, B

BOOL SQLInstallTranslatorEx( LPCTSTR lpszTranslator, LPCTSTR lpszPathIn, LPTSTR lpszPathOut, WORD cbPathOutMax, WORD pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount )

def odbccp32_SQLInstallTranslatorEx(jitter, get_str, set_str): ret_ad, args = jitter.func_args_stdcall(["lpszTranslator", "lpszPathIn", "lpszPathOut", "cbPathOutMax", "pcbPathOut", "fRequest", "lpdwUsageCount"]) raise RuntimeError('API not implemented') jitter.func_ret_stdcall(ret_ad, ret_value)

def odbccp32_SQLInstallTranslator(jitter, get_str, set_str): ret_ad, args = jitter.func_args_stdcall(["lpszInfFile", "lpszTranslator", "lpszPathIn", "lpszPathOut", "cbPathOutMax", "pcbPathOut", "fRequest", "lpdwUsageCount"]) raise RuntimeError('API not implemented') jitter.func_ret_stdcall(ret_ad, ret_value)

Helper function that returns the AmpLayout.Layout name for a given index. See amp.validator.AmpLayout.Layout in validator.proto for details.

def GetLayout(validator_pb2, layout_index): amp_layout = validator_pb2.DESCRIPTOR.message_types_by_name['AmpLayout'] layouts = amp_layout.fields_by_name['supported_layouts'].enum_type.values return layouts[layout_index].name

def get_label(index): if index == 0: return "Sepal Length" if index == 1: return "Sepal Width" if index == 2: return "Petal Length" if index == 3: return "Petal Width"

when removing a room we wan't to be able to remove it from the cache as well

def remove_room_exists(self, channel_id, room_id):

def rm_from_cache(self, *args, **kwargs): try: del self._cache[self._prehash( bind_callargs(self._signature, *args, **kwargs) )] except KeyError: pass

Generates a trajectory given a path. Does it using splines for each of the x, y, z

def create_trajectory(self, path): # Added this last pose because in some cases the drone would stop at the before-last pose. # Couldn't figure out the reason for this, I plotted the splines and they seemed fine. It # looks like some bug in the crazyflie firmware. path.add_pose(path.poses[-1], path.times[-1] + EPS) self.__duration = path.times[-1] # Generates splines for x, y and z, using the t array as knots. x_spline = CubicSpline(path.times, [p.position().x for p in path.poses], bc_type='natural') y_spline = CubicSpline(path.times, [p.position().y for p in path.poses], bc_type='natural') z_spline = CubicSpline(path.times, [p.position().z for p in path.poses], bc_type='natural') # Passing to the structure ros will read. Note that the polynomials must have 8 constants. for i in range(1, len(path.times)): x_coef = np.concatenate((x_spline.c[:, i - 1][::-1], [0] * 4)) y_coef = np.concatenate((y_spline.c[:, i - 1][::-1], [0] * 4)) z_coef = np.concatenate((z_spline.c[:, i - 1][::-1], [0] * 4)) p = Polynomial4D(path.times[i] - path.times[i - 1], x_coef, y_coef, z_coef, [0] * 8) self.__polynomials.append(p)

def generate_spiral_path_dtu(poses, n_frames=120, n_rots=2, zrate=.5, perc=60): # Get radii for spiral path using 60th percentile of camera positions. positions = poses[:, :3, 3] radii = np.percentile(np.abs(positions), perc, 0) radii = np.concatenate([radii, [1.]]) # Generate poses for spiral path. render_poses = [] cam2world = poses_avg(poses) up = poses[:, :3, 1].mean(0) z_axis = focus_pt_fn(poses) for theta in np.linspace(0., 2. * np.pi * n_rots, n_frames, endpoint=False): t = radii * [np.cos(theta), -np.sin(theta), -np.sin(theta * zrate), 1.] position = cam2world @ t render_poses.append(viewmatrix(z_axis, up, position, True)) render_poses = np.stack(render_poses, axis=0) return render_poses

Unlike a given repo on the Hub (e.g. remove from favorite list). See also [`like`] and [`list_liked_repos`].

def unlike( self, repo_id: str, *, token: Optional[str] = None, repo_type: Optional[str] = None, ) -> None: if repo_type is None: repo_type = REPO_TYPE_MODEL response = get_session().delete( url=f"{self.endpoint}/api/{repo_type}s/{repo_id}/like", headers=self._build_hf_headers(token=token) ) hf_raise_for_status(response)

def repository(full_name): session = db.get_session() try: repository = session.query(Repository) \ .filter(Repository.full_name == full_name) \ .one() commit_shas = session.query(Commit.sha) \ .join( commit_repository, commit_repository.c.repository_clone_url == repository.clone_url, ) \ .filter(commit_repository.c.commit_sha == Commit.sha) \ .all() commit_shas = [c[0] for c in commit_shas] if commit_shas: session.query(Commit) \ .filter(Commit.sha.in_(commit_shas)) \ .delete(synchronize_session=False) session.query(Repository) \ .filter(Repository.full_name == full_name) \ .delete() session.commit() finally: session.close()

국외로 나가지 않고도 베를린 필하모닉 오케스트라가 운영하는 공연 실황중계 시스템을 통해 공연을 관람할 수 있다.

베를린 필하모닉 오케스트라가 공연 실황중계 시스템을 구축함으로 인해 국내에서도 인터넷을 통해 공연 관람이 가능하다.

서로가 하는 공연 관람을 서울, 부산을 오가며 했고 공연을 마치면 함께 소주를 마셨다.

The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.

def drain_timeout_in_sec(self) -> int: return pulumi.get(self, "drain_timeout_in_sec")

def KeepAliveTimeout(self): return self._get_attribute('keepAliveTimeout')

걔가 한 달에 버는 돈은 얼마야

걔가 한 달에 버는 돈이 되는데?

그러면 갈 때마다 얼마씩 걷는 거야 아니며 매달 얼마씩 걷는 거야?

Goes through all functions to calculate all important numbers for the tree Calculates num_child, num_grand, tree_size, depth

def calc_all(self): self.calc_num_child() # calculate number of children self.calc_num_grand() # calculate number of grandkids self.calc_tree_size() # calculate number of tree size self.calc_depth() self.calc_max_depth()

def calc_num_child(self): self.num_child = len(self.children) # count num of kids for child in self.children: # Go thru all kids child.calc_num_child() # Ask each kid to take stock also

Fit a quadratic around a point and find its local minimum/maximum Center should be in row,column format

def fitquadratic(im,center,n): w = int((n-1)/2) start = center - w patch = im[start[0]:(start[0]+n), start[1]:(start[1]+n)] x0 = (n+1)/2 x,y = np.meshgrid(range(n),range(n)) x = x.flatten()+1-x0 y = y.flatten()+1-x0 # Constants for coefficient vector [f a b c d e] A = np.vstack([np.ones(n*n), x**2, y**2, x*y, x, y]).T coef = np.linalg.lstsq(A, patch.flatten())[0] # Find minimum coordinates B = np.array([[2*coef[1], coef[3]], [coef[3], 2*coef[2]]]) rhs = np.array([[-coef[4]],[-coef[5]]]) # [2a c; c 2b][x;y]=-[d;e] xymin = np.linalg.lstsq(B,rhs)[0] xymin += np.array([[center[1]],[center[0]]]) return xymin, coef

def closest_point_to(self, x): min_pt, min_dist = None, np.inf for s in self.segments: s_min_dist, s_min_pt = s.closest_point_to(x) if s_min_dist < min_dist: min_dist = s_min_dist min_pt = s_min_pt sd = np.copysign(min_dist, -1 if self.is_inside(x) else 1) return sd, min_pt

Return an instance of BlackjackMDP where peeking is the optimal action at least 10% of the time.

def peekingMDP(): # BEGIN_YOUR_CODE (our solution is 2 lines of code, but don't worry if you deviate from this) return BlackjackMDP(cardValues=[4, 5, 10, 11], multiplicity=1, threshold=20, peekCost=1) # END_YOUR_CODE

def _greedy_policy(self, state): raise NotImplementedError

인큐베이터에서 병아리 알을 부화하는 데 얼마나 걸립니까?

그렇다면 수정된 닭 알이 부화하는 데 얼마나 걸릴까요? 그에 대한 답은 정확히 21일입니다. 그러나 여러 가지 상황에 따라 달라질 수 있다는 점을 염두에 두어야 합니다. 어떤 이유로 인해 온도가 적정 온도 이하로 떨어진 경우, 일부 알은 22일, 23일, 또는 심지어 24일이나 25일에 부화할 수 있습니다. 수정된 닭 알은 일반적으로 정확히 21일이 걸리는 반면, 대부분의 오리 알은 28일이 걸리며, 무스코비 오리를 제외합니다.

닭 알은 일반적으로 부화하기 전에 약 21일 동안 인큐베이션됩니다.

민준이, 여름, 휴가, 기차, 여행, 떠나다, 하다

민준이는 여름 휴가로 혼자 기차 여행을 떠나기로 했다.

재주는 예절, 음악, 활쏘기, 글쓰기, 말타기, 계산하기 등등 이다.

전자 환원반응을 통해 세포와 조직에 독성을 일으키는건 뭐야?

$ \mathrm{O}_{2}^{-} $은 전자 환원반응을 통해 세포와 조직에 독성을 일으켜 질병을 유발시키며, 이는 노화와 밀접한 관련이 있는 것으로 알려져 있다.

이는 본 연구에서 농화배양된 혼합미생물이 환원전극 반응기 내에서 전극으로 부터 전자를 받아 $ \mathrm{CO}_{2} $ 를 아세트산으로 환원하는 생물전기활성반응을 일으키는 것을 나타낸다.

사용되다, 치료제, 통증, 봉독

봉독은 주로 통증 치료제로 사용되어 왔다.

샐러드의 양념으로 주로 소금, 후추, 향료, 케이퍼 등이 사용되고 있다.

Return a dictionary of css dictionaries representing this scheme. This can be fed to the ly.colorize.format_stylesheet() function.

def css_scheme(self): scheme = {} # base/default styles d = scheme[None] = {} for name, fmt in self.defaultStyles.items(): d[name] = fmt2css(fmt) # mode/group styles for mode, styles in self.allStyles.items(): d = scheme[mode] = {} for name, fmt in styles.items(): d[name] = fmt2css(fmt) return scheme

def stylers(self): if self._stylers is None: self._stylers = styler_factory(self.project_config().get('style', {})) return self._stylers

Verifies that the report is not accredited if it contains a sample application that is not accredited.

def test_get_report_accreditation_false(report_api_mip_dna, mip_analysis_api, case_mip_dna): # GIVEN a list of samples when one of them is not accredited mip_metadata = mip_analysis_api.get_latest_metadata(case_mip_dna.internal_id) samples = report_api_mip_dna.get_samples_data(case_mip_dna, mip_metadata) samples[0].application.accredited = False # WHEN retrieving the report accreditation accredited = report_api_mip_dna.get_report_accreditation(samples) # THEN check that the report is not accredited assert not accredited

def test_get_sample_bad_sample(cli_runner: CliRunner, base_context: CGConfig): # GIVEN an empty database # WHEN getting a sample name = "dummy_name" result = cli_runner.invoke(get, ["sample", name], obj=base_context) # THEN it should warn about missing sample id instead of getting a sample # it will not fail since the API accepts multiple samples assert result.exit_code == 0

Search for documents based on type filters, search_text or order_by and return a queryset of document objects

def search_documents(self, types=None, search_text=None, order_by=None): documents = self if types and isinstance(types, list) and types[0] != 'all': documents = documents.filter(type__in=types) if search_text: documents = documents.filter(Q(name__icontains=search_text) | Q(description__icontains=search_text) | Q(search__icontains=search_text)) if order_by: # TODO: Validate that order_by is a valid sort parameter documents = documents.order_by(order_by) return documents

def search(self, query_string, fields=None, backend='default'): search_backend = get_search_backend(backend) return search_backend.search(query_string, self, fields=None)

Performs a single read from the socket and hands the data off to the h2 connection object.

def _single_read(self): # Begin by reading what we can from the socket. # # Concurrency # # Synchronizes reading the data # # I/O occurs while the lock is held; waiting threads will see a delay. with self._lock: if self._sock is None: raise ConnectionError('tried to read after connection close') self._sock.fill() data = self._sock.buffer.tobytes() self._sock.advance_buffer(len(data)) with self._conn as conn: events = conn.receive_data(data) stream_ids = set(getattr(e, 'stream_id', -1) for e in events) stream_ids.discard(-1) # sentinel stream_ids.discard(0) # connection events self.recent_recv_streams |= stream_ids for event in events: if isinstance(event, h2.events.DataReceived): self._adjust_receive_window(event.flow_controlled_length) self.streams[event.stream_id].receive_data(event) elif isinstance(event, h2.events.PushedStreamReceived): if self._enable_push: self._new_stream(event.pushed_stream_id, local_closed=True) self.streams[event.parent_stream_id].receive_push(event) else: # Servers are forbidden from sending push promises when # the ENABLE_PUSH setting is 0, but the spec leaves the # client action undefined when they do it anyway. So we # just refuse the stream and go about our business. self._send_rst_frame(event.pushed_stream_id, 7) elif isinstance(event, h2.events.ResponseReceived): self.streams[event.stream_id].receive_response(event) elif isinstance(event, h2.events.TrailersReceived): self.streams[event.stream_id].receive_trailers(event) elif isinstance(event, h2.events.StreamEnded): self.streams[event.stream_id].receive_end_stream(event) elif isinstance(event, h2.events.StreamReset): if event.stream_id not in self.reset_streams: self.reset_streams.add(event.stream_id) self.streams[event.stream_id].receive_reset(event) elif isinstance(event, h2.events.ConnectionTerminated): # If we get GoAway with error code zero, we are doing a # graceful shutdown and all is well. Otherwise, throw an # exception. self.close() # If an error occured, try to read the error description from # code registry otherwise use the frame's additional data. if event.error_code != 0: try: name, number, description = errors.get_data( event.error_code ) except ValueError: error_string = ( "Encountered error code %d" % event.error_code ) else: error_string = ( "Encountered error %s %s: %s" % (name, number, description) ) raise ConnectionError(error_string) else: log.info("Received unhandled event %s", event) self._send_outstanding_data(tolerate_peer_gone=True, send_empty=False)

def read(self): assert self.status in (WAIT_LEN, WAIT_MESSAGE) if self.status == WAIT_LEN: self._read_len() # go back to the main loop here for simplicity instead of # falling through, even though there is a good chance that # the message is already available elif self.status == WAIT_MESSAGE: read = self.socket.recv(self.len - len(self.message)) if len(read) == 0: logging.error("can't read frame from socket (get %d of %d bytes)" % (len(self.message), self.len)) self.close() return self.message += read if len(self.message) == self.len: self.status = WAIT_PROCESS

Verify that a generated quote came from a trusted TPM and matches the previously obtained PCR values

def quote_verify(data, validation, aik, pcrvalues): select = 0 maxpcr = 0 # Verify that the validation blob was generated by a trusted TPM pubkey = aik.get_pubkey() n = m2.bin_to_bn(pubkey) n = m2.bn_to_mpi(n) e = m2.hex_to_bn("010001") e = m2.bn_to_mpi(e) rsa = M2Crypto.RSA.new_pub_key((e, n)) m = hashlib.sha1() m.update(data) md = m.digest() try: ret = rsa.verify(md, str(validation), algo='sha1') except M2Crypto.RSA.RSAError: return False # And then verify that the validation blob corresponds to the PCR # values we have values = bytearray() for pcr in sorted(pcrvalues): values += pcrvalues[pcr] select |= (1 << pcr) maxpcr = pcr if maxpcr < 16: header = struct.pack('!H', 2) header += struct.pack('@H', select) header += struct.pack('!I', len(values)) else: header = struct.pack('!H', 4) header += struct.pack('@I', select) header += struct.pack('!I', len(values)) pcr_blob = header + values m = hashlib.sha1() m.update(pcr_blob) pcr_hash = m.digest() if pcr_hash == data[8:28]: return True else: return False

def test_change_secret(self): sig1 = self.notary.compute_signature(self.nb) self.notary.secret = b"different" sig2 = self.notary.compute_signature(self.nb) self.assertNotEqual(sig1, sig2)

this function returns the list of animals with a new session within the last few ('days_passed') days

def get_current_animals(root: Root, days_passed: int = 4): now = datetime.datetime.now() all_animals = root.get_all_animals() if all_animals == []: logging.warning('No animal found!') return [] animalList = [] for animal in all_animals: animalTag = File(root, animal) sessionList = animalTag.get_all_sessions() if not sessionList: continue lastSessionDate = animalTag.get_session_date(sessionList[-1]) if (now - lastSessionDate).days <= days_passed: animalList.append(animal) return animalList

def ended_recently(self): return self.filter( status=Contest.CLOSED, created_at__gt=timezone.now()-(SUBMISSIONS_LENGTH+VOTING_LENGTH+RECENT_LENGTH) ).order_by("-created_at")

Activated at the end of the with statement. It automatically releases the lock if it isn't locked.

def __exit__(self, exc_type, exc_val, exc_tb): if self.is_locked: self.release()

def unlock(self): utilities.lock.unlock(self.lockfd)

Returns the mean squared error for model (a polynomial of the specified degree) on X and y.

def mse(X, y, degree, model): # calculate MSE for X and y and return both MSE_x = np.square(np.subtract(X, model[0])).mean()/len(X) MSE_y = np.square(np.subtract(y, model[1])).mean()/len(y) return MSE_x, MSE_y

def error(self, x: np.array, y: np.array) -> float: yh = self.predict(x) return np.mean(y != yh)

있다, 실속, 땅, 땅, 가치, 귀하다

그 땅은 실속이 있고 경제적 가치가 귀한 땅이다.

수박, 참외, 조롱박, 수세미, 오이, 가지를 정성껏 심어 무럭무럭 키웠다.

통영시와 통영 폐조선소 재생사업 협약을 체결한 건 어디지?

한국토지주택공사(LH)는 통영시 소재 신아sb조선소에서 경상남도, 통영시와 통영 폐조선소 재생사업 기본협약을 체결했다고 30일 밝혔다

한국토지주택공사(LH)는 통영 폐조선소 재생사업 마스터플랜 국제공모 당선작으로 포스코에이앤씨 컨소시엄의 통영 캠프 마레를 최종선정했다고 10일 밝혔다

Given a RefID and an optional name, create a profile and then return that newly created profile.

def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], pid: Optional[int]) -> ValidatedDict: if refid is None: return None if name is None: name = 'なし' if pid is None: pid = 51 userid = self.data.remote.user.from_refid(self.game, self.version, refid) defaultprofile = ValidatedDict({ 'name': name, 'pid': pid, 'settings': { 'flags': 223 # Default to turning on all optional folders }, }) self.put_profile(userid, defaultprofile) profile = self.get_profile(userid) return profile

def post_create_user(sender, instance, created, raw, **kwargs): if created and not raw: user = instance (user_profile, created) = UserProfile.objects.get_or_create( user=user )

Try to match country name with its code. Name of the city helps when country_name is "Korea".

def match_country_name_to_its_code(country_name, city=''): if country_name: country_name = country_name.upper().replace('.', '').strip() if country_to_iso_code.get(country_name): return country_to_iso_code.get(country_name) elif country_name == 'KOREA': if city.upper() in south_korean_cities: return 'KR' else: for c_code, spellings in countries_alternative_spellings.items(): for spelling in spellings: if country_name == spelling: return c_code return None

def find_code(city_name): try: code_2 = pycountry.subdivisions.lookup(city_name) code_3 = pycountry.countries.get(alpha_2=code_2.country_code) return code_3.alpha_3 except LookupError: print(f'Sorry, could not find a code for {city_name}', file=sys.stderr) return 'XXX'

takes a path to a folder and write all filenames recursively (files of all sub folders to)

def get_all_file_names(folderpath, out="../output.txt"): print("folder pathh: ", folderpath) file_list = os.listdir(folderpath) print("file_list:") print(file_list) with open(out, "a") as file2: for object_name in file_list: file2.write(str(object_name) + "\n") dir_path = os.path.join(folderpath, str(object_name)) if os.path.isdir( dir_path ): # Return True if path is an existing directory. This follows symbolic links, so both islink() and isdir() can be true for the same path.) print("Is dir", dir_path) get_all_file_names(dir_path, out)

def get_files_in_folder(folder): filenames = os.listdir(folder) # os.path.join combines paths while dealing with /s and \s appropriately full_filenames = [os.path.join(folder, filename) for filename in filenames] return full_filenames

콘크리트 슬래브 비용

우리의 콘크리트 슬래브 자재 추정에 따르면, 콘크리트 슬래브의 평균 최소 비용은 평방피트당 1.36달러이며, 최대 비용은 1.88달러입니다. 비교하자면, 시멘트 슬래브의 평방피트당 가격은 5.50달러입니다.

콘크리트 슬래브와 포장재의 비용 비교. 일반적으로 표준 콘크리트 슬래브는 대안보다 제곱피트당 비용이 낮습니다. 일반적으로 표준 콘크리트 슬래브 대신 포장석을 선택할 경우 10%-15% 더 지불하게 됩니다. 스탬프 콘크리트로 업그레이드하기로 결정하면, 대부분의 경우 포장석의 비용이 동일하거나 더 저렴할 가능성이 높습니다.

Processes a range of filenames and labels in the MPII dataset corresponding to the given thread index.

def _process_image_files_single_thread(coder, thread_index, ranges, mpii_dataset): if FLAGS.is_train: base_name = 'train' else: base_name = 'test' shards_per_thread = FLAGS.train_shards/FLAGS.num_threads shard_ranges = pose_util.get_n_ranges(ranges[thread_index][0], ranges[thread_index][1], shards_per_thread) for shard_index in range(len(shard_ranges)): tfrecord_index = int(thread_index*shards_per_thread + shard_index) tfrecord_filename = '{}{}.tfrecord'.format(base_name, tfrecord_index) tfrecord_filepath = os.path.join(FLAGS.train_dir, tfrecord_filename) options = tf.python_io.TFRecordOptions( compression_type=tf.python_io.TFRecordCompressionType.ZLIB) with tf.python_io.TFRecordWriter(path=tfrecord_filepath, options=options) as writer: shard_start = shard_ranges[shard_index][0] shard_end = shard_ranges[shard_index][1] for img_index in range(shard_start, shard_end): with tf.gfile.FastGFile(name=mpii_dataset.img_filenames[img_index], mode='rb') as f: image_jpeg = f.read() _write_example(coder, image_jpeg, mpii_dataset.people_in_imgs[img_index], writer)

def parallel_search_range(data, query_range, n_processor): results = [] pool = Pool(processes=n_processor) ### START CODE HERE ### # Perform data partitioning first partition_result=h_partition(data,n_processor) for query in range(query_range[0],query_range[1]+1): hash_value=s_hash(query,n_processor) working_dataset=partition_result[hash_value] indices=pool.apply(linear_search,[working_dataset,query]) for index in indices: results.append(working_dataset[index]) ### END CODE HERE ### return results