a\\\").text,\\n 'Not found!')\\n except:\\n current_url = self.driver.current_url\\n resp = requests.get(current_url)\\n if resp.status_code != 200:\\n raise Exception(\\\"Search failed! => [%s] %s\\\" % (resp.status_code,\\n current_url))\",\n \"def click(self, element):\\n element.click()\",\n \"def click(self, selector):\\n el = self.locate_element(selector)\\n el.click()\",\n \"def click_document_search_button(self):\\n self.click_element(self.document_search_button_locator, True)\",\n \"def handle_text_search(self, text):\\n log.debug(\\\"Handling text search: %s\\\", text)\\n\\n self.current_selected = 0\\n self._refresh()\",\n \"def doWaitClickElement(self, timeout=10.0, name=None, tagName=None, className=None,\\n id=None, xpath=None, linkText=None, partialLinkText=None, cssSelector=None,\\n location=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n more = {}\\n if self.cfg['wait-until']:\\n more = {\\\"wait-until\\\": True, \\\"wait-until-timeout\\\": timeout}\\n \\n if not self.cfg['wait-until']:\\n cmdId = self.implicitlyWait(timeout=timeout)\\n if self.isWait(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\\n\\n cmdId = self.findElement(elementId=None, name=name, tagName=tagName, className=className,\\n id=id, xpath=xpath, linkText=linkText, partialLinkText=partialLinkText, cssSelector=cssSelector,\\n location=location, more=more)\\n rsp = self.hasElement(timeout=timeout+10, commandId=cmdId) \\n if rsp is None: \\n ret = False\\n return ret\\n \\n elementVall = rsp.get('GUI', 'value')\\n elementId = elementVall.get('element-id')\\n \\n cmdId = self.clickElement(elementId=elementId)\\n if self.isElementClicked(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\",\n \"def enable_search(self):\\n html_element = self.find_element_by_xpath(\\n '/html/body').get_attribute('outerHTML')\\n soup = Scraper(html_element)\\n\\n elms_obj = soup.find_search_enable_btn()\\n\\n for tag, target in elms_obj.items():\\n if len(target) > 0:\\n for elem in target:\\n for attr, value in elem.items():\\n try:\\n if str(attr) == 'class':\\n for element in value:\\n btn = self.find_elements_by_class_name(\\n f'{element}')\\n for e in btn:\\n try:\\n e.click()\\n print(\\n colored(':: The Searching is able ::', 'green'))\\n return\\n except:\\n print(\\n 'The searching isn\\\\'t able yet =(')\\n except:\\n pass\\n btn = self.find_elements_by_css_selector(\\n f'{tag}[{attr}=\\\"{value}\\\"]'\\n )\\n for element in btn:\\n try:\\n element.click()\\n print(\\n colored(':: The Searching is able ::', 'green'))\\n return\\n except:\\n print('The searching isn\\\\'t able yet =(')\",\n \"def make_click(self, xpath):\\n\\n self.driver.find_element_by_xpath(xpath).click()\",\n \"def input_text(self, element: Union[WebElement, Tuple[By, str]], text: str):\\n element = self.find_element(element)\\n element.send_keys(text)\",\n \"def click(self, xpath):\\n self.driver.find_element_by_xpath(xpath=xpath).click()\",\n \"def _get_text(locator, timeout=default_timeout, type = By.XPATH):\\n logger.debug(\\\"Entered _get_text() method\\\")\\n button = _find_element(locator, type = type, timeout = timeout)\\n if button:\\n return button.text\\n return None\",\n \"def tap():\\n return \\\"I have clicked on the elements\\\"\",\n \"def click_on(name, scope=driver):\\n try:\\n #print('click_on')\\n name = name.lower().strip()\\n links = scope.find_elements_by_xpath(\\\".//a[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s')]\\\" % (name))\\n for element in links:\\n if element.is_displayed():\\n try:\\n element.click()\\n except:\\n driver.execute_script(\\\"arguments[0].click();\\\", element)\\n #element.click()\\n #print(element.text)\\n wait()\\n #print(\\\"Link\\\")\\n return \\\"Success\\\"\\n \\n buttons = scope.find_elements_by_xpath(\\\".//button[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s')]\\\" % (name))\\n for element in buttons:\\n if element.is_displayed():\\n try:\\n element.click()\\n except:\\n driver.execute_script(\\\"arguments[0].click();\\\", element)\\n #element.click()\\n #print(element.text)\\n wait()\\n #print(\\\"Button\\\")\\n return \\\"Success\\\"\\n\\n inputs = scope.find_elements_by_xpath(\\\".//input[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s') or contains(translate(@placeholder, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s') or contains(translate(@value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s')]\\\" % (name, name, name))\\n for element in inputs:\\n if element.is_displayed():\\n try:\\n element.click()\\n except:\\n driver.execute_script(\\\"arguments[0].click();\\\", element)\\n #element.click()\\n #print(element.text)\\n wait()\\n #print(\\\"Input\\\")\\n return \\\"Success\\\"\\n \\n remaining_elements = scope.find_elements_by_xpath(\\\".//*[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s') or contains(translate(@placeholder, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s') or contains(translate(@value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '%s')]\\\" % (name, name, name))\\n for element in remaining_elements:\\n if element.is_displayed():\\n try:\\n element.click()\\n except:\\n driver.execute_script(\\\"arguments[0].click();\\\", element)\\n #element.click()\\n #print(element.text)\\n wait()\\n #print(\\\"Remaining\\\")\\n return \\\"Success\\\"\\n if len(remaining_elements) == 0:\\n wait()\\n return \\\"Error: no element with text '\\\" + name +\\\"' found\\\"\\n except Exception as e:\\n wait()\\n return \\\"Error: \\\" + str(e)\\n return \\\"Error: no element with text '\\\" + name +\\\"' found\\\"\",\n \"def click_outbound_statement_search_button(self):\\n self.click_element(self.page_header_locator)\\n self.click_element(self.outbound_statement_search_button_locator, True)\",\n \"def atomacclick(objecttoclick):\\n try:\\n objecttoclick.Press()\\n #print \\\"clicked on : %s\\\" %objecttoclick\\n except Exception as er:\\n print \\\"Not able to click on: %s\\\" %objecttoclick\",\n \"def get_text_in_element():\\n nonlocal text_\\n if text_ is None:\\n text_ = element.text\\n element_text = element.text\\n if element_text == text:\\n return element\\n if text.lower() == element_text.lower():\\n return element\\n if \\\"\\\".join(text.split()) == \\\"\\\".join(element_text.split()):\\n return element\\n return False\",\n \"def enter(self, selector, text):\\n try:\\n self._wait_element_localed(self.driver, selector)\\n element = self.get_element(selector)\\n element.send_keys(text)\\n except:\\n raise NoSuchElementException(\\\"no such element found\\\")\",\n \"def get_locator(locator_text: str, locator_type: str = \\\"id\\\") -> tuple:\\n locator = locator_type.upper()\\n return getattr(By, locator), locator_text\",\n \"def click_element(self, element: Union[WebElement, Tuple[By, str]]):\\n element = self.find_element(element)\\n element.click()\",\n \"def doDoubleClickElement(self, timeout=10.0, name=None, tagName=None, className=None,\\n id=None, xpath=None, linkText=None, partialLinkText=None, \\n cssSelector=None, location=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n \\n if not self.cfg['wait-until']:\\n cmdId = self.implicitlyWait(timeout=timeout)\\n if self.isWait(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\\n \\n cmdId = self.findElement(elementId=None, name=name, tagName=tagName, className=className,\\n id=id, xpath=xpath, linkText=linkText, partialLinkText=partialLinkText, \\n cssSelector=cssSelector, location=location)\\n rsp = self.hasElement(timeout=timeout, commandId=cmdId) \\n if rsp is None: ret = False\\n else:\\n elementVall = rsp.get('GUI', 'value')\\n elementId = elementVall.get('element-id')\\n \\n cmdId = self.hoverElement(elementId=elementId)\\n if self.hasMouseMoved(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n else:\\n cmdId = self.doubleClick()\\n if self.isDoubleClicked(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n\\n return ret\",\n \"def doRightClickElement(self, timeout=10.0, name=None, tagName=None, className=None,\\n id=None, xpath=None, linkText=None, partialLinkText=None, \\n cssSelector=None, location=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n \\n if not self.cfg['wait-until']:\\n cmdId = self.implicitlyWait(timeout=timeout)\\n if self.isWait(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\\n \\n cmdId = self.findElement(elementId=None, name=name, tagName=tagName, className=className,\\n id=id, xpath=xpath, linkText=linkText, partialLinkText=partialLinkText, \\n cssSelector=cssSelector, location=location)\\n rsp = self.hasElement(timeout=timeout, commandId=cmdId) \\n if rsp is None: ret = False\\n else:\\n elementVall = rsp.get('GUI', 'value')\\n elementId = elementVall.get('element-id')\\n \\n cmdId = self.hoverElement(elementId=elementId)\\n if self.hasMouseMoved(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n else:\\n cmdId = self.rightClick()\\n if self.isClicked(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n\\n return ret\",\n \"def click_button(self):\\n self.q(css='div#fixture input').first.click()\",\n \"def find_element_by_text_excepted(self, text, text_excepted):\\n return self.wait_for_element_by_xpath(\\\"//*[contains(text(), '%s')][not(contains(text(), '%s'))]\\\" % (text, text_excepted))\",\n \"def doGetText(self, timeout=10.0, name=None, tagName=None, className=None,\\n id=None, xpath=None, linkText=None, partialLinkText=None, cssSelector=None,\\n location=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n \\n if not self.cfg['wait-until']:\\n cmdId = self.implicitlyWait(timeout=timeout)\\n if self.isWait(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\\n \\n cmdId = self.findElement(elementId=None, name=name, tagName=tagName, className=className,\\n id=id, xpath=xpath, linkText=linkText, partialLinkText=partialLinkText, \\n cssSelector=cssSelector, location=location)\\n rsp = self.hasElement(timeout=timeout, commandId=cmdId) \\n if rsp is None: ret = False\\n else:\\n elementVall = rsp.get('GUI', 'value')\\n elementId = elementVall.get('element-id')\\n \\n cmdId = self.getTextElement(elementId=elementId)\\n rsp = self.hasTextElement(timeout=timeout, commandId=cmdId)\\n if rsp is None: ret = False\\n else:\\n elementVall = rsp.get('GUI', 'value')\\n ret = elementVall.get('value')\\n \\n return ret\",\n \"def test_search_2(self):\\n\\n # type \\\"cheese\\\" into the search field\\n s('[name=\\\"q\\\"]') \\\\\\n .set_value('cheese')\\n\\n # click the \\\"Google Search\\\" button\\n s('[name=\\\"btnK\\\"]') \\\\\\n .click()\\n\\n # check that results are shown\\n s('#resultStats') \\\\\\n .should(be.visible)\",\n \"def click_element_by_xpath(self,param,ignore_error_handle=False):\\n message = {};\\n step = 'Click element by it\\\\'s xpath {xpath}'.format(xpath=param['xpath'])\\n try:\\n xpath = param['xpath'];\\n element = self.driver.find_element_by_xpath(xpath);\\n element.click()\\n message = self.feedback.feedback_action_ok(step)\\n except BaseException,e:\\n message = self.feedback.feedback_action_fail(step,str(e),ignore_error_handle)\\n finally:\\n return message\",\n \"def click_inbound_statement_search_button(self):\\n self.click_element(self.page_header_locator)\\n self.click_element(self.inbound_statement_search_button_locator, True)\",\n \"def click_button(button_to_click):\\n try:\\n button_to_click.click()\\n except:\\n print(\\\"Button not found\\\")\",\n \"def test_search_1200(self):\\n self.driver.get(self.domain)\\n self.driver.maximize_window()\\n self.assertTrue(u'TITLE' in\\n self.driver.page_source, 'Title text not found')\\n search = self.driver.find_element_by_css_selector(\\\"#XXXX\\\")\\n wait = ui.WebDriverWait(self.driver, 5)\\n search.clear()\\n search.send_keys(\\\"XXXX\\\")\\n search.submit()\\n try:\\n wait.until(lambda driver: u\\\"XXXX\\\" in\\n self.driver.find_element_by_css_selector(\\\"xxxx > a\\\").text,\\n 'Not found!')\\n except:\\n current_url = self.driver.current_url\\n resp = requests.get(current_url)\\n if resp.status_code != 200:\\n raise Exception(\\\"Search failed! => [%s] %s\\\" % (resp.status_code,\\n current_url))\",\n \"def do_click(self, xpath):\\n e = self._find_element_by_xpath(xpath)\\n e.click()\",\n \"def search():\\n url = create_search_url()\\n links = make_selenium_search(url)\\n\\n return links\",\n \"def test_navigates_to_index_page_link_about_page(w_driver):\\n w_driver.get('localhost:8000')\\n \\n element=w_driver.find_element_by_link_text('About our team').click()\\n results=w_driver.page_source\\n text_found=re.search(r'About the Kasner Search Engine',results)\\n\\n assert(text_found != None)\",\n \"def click(self, selector, index=0):\\n self.find_css(selector).nth(index).click()\",\n \"def click_element_by_xpath(self, xpath):\\n try:\\n print(f\\\"xpath provided: {xpath}\\\")\\n #element = driver.find_element_by_xpath(xpath)\\n element = self.wwait.until(EC.element_to_be_clickable((By.XPATH, xpath)))\\n utils.LOG.info(\\\"clicking the element\\\")\\n element.click()\\n except NoSuchElementException as err:\\n utils.LOG.error(f\\\"Check element by following xpath\\\")\\n utils.LOG.error(err)\\n self.take_screenshot('ErrorClickElement')\",\n \"def find_elements_by_text(self,param={},ignore_error_handle = False):\\n message = {};\\n step = 'find all elements by text ' + param.get('text',None) + ' on current page';\\n text = param.get('text',None);\\n try:\\n elements = self.driver.find_elements(by=By.NAME,value=text);\\n message = self.feedback.feedback_action_ok(step);\\n message['elements'] = elements;\\n except BaseException,e:\\n message = self.feedback.feedback_action_fail(step,str(e),ignore_error_handle);\\n finally:\\n return message;\",\n \"def click(key, timeout=default_timeout):\\n WILD = \\\"**\\\" # Indicates places where keys can have variable text.\\n WILDNUM = \\\"##\\\" # Variable number\\n\\n # Map of functions and the keys they may be used to click on.\\n map = { \\\"click_function_key\\\": ['KEY IN CODE', 'HELP', 'PAY'],\\n \\\"click_welcome_key\\\": ['START'],\\n \\\"click_help_key\\\": ['REQUEST ASSISTANCE', 'BACK', 'WEIGHTS AND MEASURES'],\\n \\\"click_weights_measures_key\\\": ['BACK'],\\n \\\"click_payment_key\\\": ['BACK', 'HELP'],\\n \\\"click_loyalty_key\\\": ['ENTER ID'],\\n \\\"click_message_box_key\\\": ['OK', 'YES', 'NO'],\\n \\\"click_prompt_key\\\": ['OK', 'YES', 'NO'],\\n \\\"click_speed_key\\\": ['GENERIC ITEM', WILD],\\n \\\"click_keypad\\\": ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '00', 'BACK', 'CLEAR', 'CANCEL', 'ENTER']\\n }\\n\\n # Figure out which functions might work for the desired key\\n def build_func_list(key):\\n import sys\\n funcs_to_try = []\\n for func in map:\\n if key.upper() in map[func]:\\n funcs_to_try.append(getattr(sys.modules[__name__], func))\\n return funcs_to_try\\n\\n # Create list of functions to search with\\n funcs_to_try = build_func_list(key)\\n if len(funcs_to_try) == 0:\\n # Requested key doesn't match any known menus, try menus that can have custom keys\\n if key.isdigit():\\n funcs_to_try = build_func_list(WILDNUM) # Menus that are likely to have buttons with varied numbers\\n else:\\n funcs_to_try = build_func_list(WILD) # Menus that can contain buttons with any text\\n \\n # Invoke the functions repeatedly until success or timeout\\n start_time = time.time()\\n while time.time() - start_time <= timeout:\\n for func in funcs_to_try:\\n if func(key, timeout=0, verify=False):\\n return True\\n else:\\n logger.warning(\\\"Couldn't find %s within %d seconds.\\\" % (key, timeout))\\n return False\",\n \"def doWaitVisibleClickElement(self, timeout=10.0, name=None, tagName=None, className=None,\\n id=None, xpath=None, linkText=None, partialLinkText=None, cssSelector=None,\\n location=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n more = {}\\n if self.cfg['wait-until']:\\n more = {\\\"wait-until\\\": True, \\\"wait-until-timeout\\\": timeout}\\n \\n if not self.cfg['wait-until']:\\n cmdId = self.implicitlyWait(timeout=timeout)\\n if self.isWait(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\\n\\n # locate the element\\n cmdId = self.findElement(elementId=None, name=name, tagName=tagName, className=className,\\n id=id, xpath=xpath, linkText=linkText, partialLinkText=partialLinkText, cssSelector=cssSelector,\\n location=location, more=more)\\n rsp = self.hasElement(timeout=timeout+10, commandId=cmdId) \\n if rsp is None: \\n ret = False\\n return ret\\n \\n elementVall = rsp.get('GUI', 'value')\\n elementId = elementVall.get('element-id')\\n \\n if elementId is None:\\n self.error(\\\"element id is missing in response\\\")\\n \\n # checking if visible\\n more = {}\\n if self.cfg['wait-until']:\\n more = {\\\"wait-until\\\": True, \\\"wait-until-timeout\\\": timeout, \\\"wait-until-value\\\": True}\\n cmdId = self.displayedElement(elementId=elementId, more= more)\\n rsp = self.isElementDisplayed(timeout=timeout+10, commandId=cmdId) \\n if rsp is None: \\n ret = False \\n return ret\\n \\n # finally click on it\\n cmdId = self.clickElement(elementId=elementId)\\n if self.isElementClicked(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\",\n \"def test_search_1(self):\\n\\n # import pdb; pdb.set_trace()\\n\\n # type \\\"cheese\\\" into the search field\\n s(by.css('[name=\\\"q\\\"]')) \\\\\\n .set_value('cheese')\\n\\n # click the \\\"Google Search\\\" button\\n s(by.css('[name=\\\"btnK\\\"]')) \\\\\\n .click()\\n\\n # check that results are shown\\n s(by.css('#resultStats')) \\\\\\n .should(be.visible)\",\n \"def find_buttons(self, button_txt):\\n button = self.driver.find_elements_by_xpath(\\\"//*[text()='{}']\\\".format(button_txt))\\n return button\",\n \"def __find(self):\\n txt = self.textCursor().selectedText()\\n self.__mainWindow.showFind(txt)\",\n \"def type_text(self, element, text):\\n try:\\n if element.is_displayed():\\n element.clear()\\n element.send_keys(text)\\n print(text + \\\" is added to textbox\\\")\\n else:\\n print(element + \\\" is not displaying\\\")\\n except Exception as e:\\n print(str(e))\",\n \"def search(self, text: str, category: str = None):\\n if category:\\n # ensuring that it will be in lowercase\\n category = category.lower()\\n\\n if not category or not category in self.search_categories:\\n category = \\\"all\\\"\\n\\n search_url = f\\\"{SITE_URL}/{self.search_categories[category]}/?adb.search={text}\\\"\\n\\n # return answer.text\\n return self.fetch_url(search_url)\",\n \"def perform_search(self):\\n\\n self.implicitly_wait(5)\\n html_element = self.find_element_by_xpath(\\n '/html/body').get_attribute('outerHTML')\\n soup = Scraper(html_element)\\n target = soup.find_search_field()\\n\\n for elem in target:\\n for attr, value in elem.items():\\n placeholder = self.find_elements_by_css_selector(\\n f'input[{attr}=\\\"{value}\\\"]'\\n )\\n for element in placeholder:\\n try:\\n element.send_keys(self.keywords)\\n element.send_keys(Keys.RETURN)\\n print(colored(':: Placeholder fullfilled ::', 'green'))\\n return\\n except:\\n print(\\n colored('Can\\\\'t type inside the search input', 'yellow'))\",\n \"def InputWithSelector(action_runner, input_text, input_selector):\\n action_runner.WaitForElement(selector=input_selector)\\n action_runner.Wait(0.5)\\n # Focus the requested element first and then enter text using single\\n # Keyboard events to bypass certain restrictions on websites.\\n action_runner.ExecuteJavaScript(\\n 'document.querySelector({{selector}}).focus()', selector=input_selector)\\n # Wait a bit to make sure the focus is properly set, otherwise we'll end up\\n # losing some characters.\\n action_runner.Wait(1)\\n action_runner.EnterText(input_text)\",\n \"def exact_match(self):\\n text_to_match = input(\\\"Enter the text to search for> \\\")\\n return text_to_match\",\n \"def findText(self):\\n\\n # Prompts user for find regex\\n findText,_ = Model.FindAndReplaceDialogBox.getResults(self)\\n model = self.getCurrentPanda()\\n start = model.index(0, 0)\\n matches = model.match(\\n start, QtCore.Qt.DisplayRole,\\n findText, -1, QtCore.Qt.MatchContains)\\n if matches:\\n index = matches[0]\\n self.getCurrentView().clearSelection()\\n self.getCurrentView().selectionModel().select(\\n index, QtCore.QItemSelectionModel.Select)\\n self.getCurrentView().scrollTo(index)\\n else:\\n self.notifyUser(\\\"No matches found.\\\")\",\n \"def find_element_by_partial_text(self,param,ignore_error_handle = False):\\n message = {}\\n step = 'find element by partial text:' + param['partial_text'];\\n partial_text = param.get('partial_text',None);\\n try:\\n element = self.driver.find_element_by_partial_text(partial_text);\\n message = self.feedback.feedback_action_ok(step);\\n message['element'] = element;\\n except BaseException,e:\\n message = self.feedback.feedback_action_fail(step,str(e),ignore_error_handle);\\n finally:\\n return message;\",\n \"def search_input(self):\\n self.driver.get(\\\"https://streeteasy.com/\\\")\\n try:\\n rental_button = self.driver.find_element_by_tag_name('Rentals')\\n\\n except NoSuchElementException:\\n sleep(2)\\n self.captcha()\\n\\n else:\\n sleep(5)\\n # rental button #\\n rental_button.click()\\n # location #\\n neighborhood = self.driver.find_element_by_id(\\\"search-areas-dropdown-input\\\")\\n neighborhood.click()\\n neighborhood.send_keys(\\\"All Midtown\\\")\\n self.driver.find_element_by_xpath('//*[@id=\\\"application\\\"]').click()\\n\\n # close pop up #\\n sleep(2)\\n try:\\n self.driver.find_element_by_xpath('//*[@id=\\\"content\\\"]/main/section[1]/div/form/div[1]/div/div[3]'\\n '/div/div/div[1]/div[2]/button').click()\\n\\n except NoSuchElementException:\\n pass\\n\\n else:\\n # price - giving it only a maximum range, not minimum (price selected $3k) #\\n sleep(2)\\n self.driver.find_element_by_xpath('//*[@id=\\\"price_to\\\"]/option[24]').click()\\n\\n # number of rooms #\\n sleep(2)\\n self.driver.find_element_by_xpath('//*[@id=\\\"content\\\"]/main/section[1]/'\\n 'div/form/div[1]/div/div[3]/fieldset/div/label[3]/span').click()\\n\\n # advanced options button #\\n try:\\n sleep(2)\\n self.driver.find_element_by_css_selector(\\\"button.Home-advancedSearchLink\\\").click()\\n\\n except NoSuchElementException:\\n pass\\n\\n else:\\n # amenities search (doorman and dog) #\\n sleep(2)\\n self.driver.find_element_by_name(\\\"amenities[doorman]\\\").click()\\n sleep(2)\\n self.driver.find_element_by_name(\\\"amenities[pets]\\\").click()\\n\\n # click the search button #\\n try:\\n sleep(3)\\n search_button = self.driver.find_element_by_xpath('//*[@id=\\\"content\\\"]/main/section[1]/div/'\\n 'form/div[1]'\\n '/div/div[4]/button')\\n search_button.click()\\n\\n except ElementClickInterceptedException:\\n sleep(2)\\n self.driver.find_element_by_xpath('//*[@id=\\\"content\\\"]/main/section[1]/div/'\\n 'form/div[1]/div/div[4]'\\n '/button').click()\",\n \"def locate_element(self, selector):\\n if \\\",\\\" not in selector:\\n return self.base_driver.find_element_by_id(selector)\\n\\n selector_by = selector.split(\\\",\\\")[0].strip()\\n selector_value = selector.split(\\\",\\\")[1].strip()\\n if selector_by == \\\"i\\\" or selector_by == 'id':\\n element = self.base_driver.find_element_by_id(selector_value)\\n elif selector_by == \\\"n\\\" or selector_by == 'name':\\n element = self.base_driver.find_element_by_name(selector_value)\\n elif selector_by == \\\"c\\\" or selector_by == 'class_name':\\n element = self.base_driver.find_element_by_class_name(selector_value)\\n elif selector_by == \\\"l\\\" or selector_by == 'link_text':\\n element = self.base_driver.find_element_by_link_text(selector_value)\\n elif selector_by == \\\"p\\\" or selector_by == 'partial_link_text':\\n element = self.base_driver.find_element_by_partial_link_text(selector_value)\\n elif selector_by == \\\"t\\\" or selector_by == 'tag_name':\\n element = self.base_driver.find_element_by_tag_name(selector_value)\\n elif selector_by == \\\"x\\\" or selector_by == 'xpath':\\n element = self.base_driver.find_element_by_xpath(selector_value)\\n elif selector_by == \\\"s\\\" or selector_by == 'css_selector':\\n element = self.base_driver.find_element_by_css_selector(selector_value)\\n else:\\n raise NameError(\\\"Please enter a valid type of targeting elements.\\\")\\n\\n return element\",\n \"def SearchText(self, text, regex=False, back=False):\\n flags = wx.stc.STC_FIND_MATCHCASE\\n if regex:\\n flags = flags | wx.stc.STC_FIND_REGEXP\\n\\n self.SearchAnchor()\\n if not back:\\n # Search forward\\n res = self.SearchNext(flags, text)\\n if res == -1:\\n # Nothing found, search from top\\n self.DocumentStart()\\n self.SearchAnchor()\\n res = self.SearchNext(flags, text)\\n else:\\n # Search backward\\n res = self.SearchPrev(flags, text)\\n if res == -1:\\n # Nothing found, search from bottom\\n self.DocumentEnd()\\n self.SearchAnchor()\\n res = self.SearchPrev(flags, text)\\n return res # returns -1 if nothing found even after wrapping around\",\n \"def test02_blog_search_box(self):\\n self.info(\\\"Use Search box in home bage.\\\")\\n self.find_element(\\\"blogs_home_search\\\").click()\\n search_box = self.find_element(\\\"blogs_search_box\\\")\\n search_box.send_keys(\\\"test\\\")\\n search_icon = self.find_element(\\\"blogs_icon_search\\\")\\n search_icon.click()\\n\\n self.info(\\\"Check search box works successfully. \\\")\\n search_results = self.find_element(\\\"blogs_search_result\\\")\\n results = search_results.find_elements_by_tag_name(\\\"li\\\")\\n results_text = self.find_element(\\\"blogs_result_text\\\")\\n self.assertIn(str(len(results)), results_text)\\n\\n self.info(\\\"Try to get one of results, should works successfully.\\\")\\n if results:\\n random_post = random.choice(results)\\n tmp = random_post.text\\n post_name = tmp[tmp.find(\\\":\\\") + 2 :]\\n random_post.find_element_by_tag_name(\\\"a\\\").click()\\n self.assertIn(post_name, self.driver.current_url)\",\n \"def ticket_chooser(ticket):\\n try:\\n # Find the ticket type's button\\n ticket_type = browser.find_element_by_xpath(ticket)\\n ticket_type.click()\\n\\n except Exception as e:\\n print(\\\"Ticket type not found\\\")\",\n \"def test_search_shoes_item_to_buy(self):\\n self.driver.find_element_by_id(\\\"search_query_top\\\").send_keys(\\\"shoes\\\")\\n self.driver.find_element_by_name(\\\"submit_search\\\").click()\\n self.driver.find_element_by_xpath(\\n \\\"/html/body/div[1]/div[2]/div/div[3]/div[2]/ul/li[2]/div/div[1]/div/a[1]/img\\\").click()\\n self.driver.find_element_by_name(\\\"Submit\\\").click()\\n time.sleep(5)\",\n \"def wait_for_text(self, locator_type, locator, text):\\n self.wait.until(EC.text_to_be_present_in_element((locator_type, locator), text))\",\n \"def generic_click_element(self, element_id, click_type=\\\"press\\\"):\\n element = self.session.findById(element_id)\\n element_type = self.get_element_type_of_object(element)\\n if click_type.lower() == \\\"select\\\" and hasattr(element, \\\"select\\\"):\\n element.select()\\n if click_type.lower() == \\\"press\\\" and hasattr(element, \\\"press\\\"):\\n element.press()\\n else:\\n self.take_screenshot()\\n message = (\\n \\\"You cannot use '%s' on element type '%s', maybe use \\\"\\n \\\"'select checkbox' instead?\\\" % (click_type, element_type)\\n )\\n raise Warning(message)\\n time.sleep(self.explicit_wait)\",\n \"def select_from_list_by_text(self, locator, *texts):\\n if not texts:\\n raise ValueError(\\\"No texts given.\\\")\\n items_str = \\\"text(s) '%s'\\\" % \\\", \\\".join(texts)\\n self._info(\\\"Selecting %s from list '%s'.\\\" % (items_str, locator))\\n select = self._get_select_list(locator)\\n for text in texts:\\n select.select_by_visible_text(text)\",\n \"def _ClickGaiaButton(self, button_text, alt_text):\\n get_button_js = '''\\n (function() {\\n var buttons = document.querySelectorAll('[role=\\\"button\\\"]');\\n if (buttons == null)\\n return false;\\n for (var i=0; i < buttons.length; ++i) {\\n if ((buttons[i].textContent.indexOf('%s') != -1) ||\\n (buttons[i].textContent.indexOf('%s') != -1)) {\\n buttons[i].click();\\n return true;\\n }\\n }\\n return false;\\n })();\\n ''' % (button_text, alt_text)\\n self._GaiaWebviewContext().WaitForJavaScriptCondition(\\n get_button_js, timeout=20)\",\n \"def id_click(elem_id):\\r\\n css_click('#{}'.format(elem_id))\",\n \"def text(self, txt):\\n\\n self.web_element.clear()\\n self.web_element.send_keys(txt)\\n return None\",\n \"def pop_up(self):\\n sleep(2)\\n self.driver.find_element_by_link_text('Got It').click()\\n self.get_search_results()\",\n \"def search_string(self, string):\\n global search_component\\n global searchBox_component\\n global searchButton_component\\n\\n search_soup = BeautifulSoup(self.res.text, 'lxml')\\n \\n search_component = get_search_component(search_soup)\\n searchBox_component = get_search_box_component(search_soup)\\n searchButton_component = get_search_button_component(search_soup)\\n\\n #This part type string on box\\n self.data['SAPEVENTQUEUE'] = \\\"ComboBox_ListAccess~E002Id~E004\\\" + \\\\\\n search_component + \\\"~E005ItemListBoxId~E004\\\" + \\\\\\n searchBox_component + \\\"~E005FilterValue~E004\\\"\\n self.data['SAPEVENTQUEUE'] = self.data['SAPEVENTQUEUE'] + str(string)\\n self.data['SAPEVENTQUEUE'] = self.data['SAPEVENTQUEUE'] + \\\"~E003~E002ResponseData~E004delta~E005ClientAction~E004submitAsync~E003~E002~E003\\\"\\n self.res = self.sess.post(self.url, data=self.data)\\n \\n #This part click \\\"search\\\" button on site\\n self.data['SAPEVENTQUEUE'] = \\\"ComboBox_Change~E002Id~E004\\\" + \\\\\\n search_component + \\\"~E005Value~E004\\\"\\n self.data['SAPEVENTQUEUE'] = self.data['SAPEVENTQUEUE'] + str(string)\\n self.data['SAPEVENTQUEUE'] = self.data['SAPEVENTQUEUE'] + \\\"~E003~E002ResponseData~E004delta~E005EnqueueCardinality~E004single~E005Delay~E004full~E003~E002~E003~E001Button_Press~E002Id~E004\\\" + \\\\\\n searchButton_component + \\\"~E003~E002ResponseData~E004delta~E005ClientAction~E004submit~E003~E002~E003\\\"\\n self.res = self.sess.post(self.url, data=self.data)\",\n \"def select_desired_index_from_the_list(self, index_name):\\n select_index = \\\"(//*[name()='svg'][@class='css-8mmkcg'])\\\"\\n select_index_sitem = self.locator_finder_by_xpath(select_index)\\n select_index_sitem.click()\\n time.sleep(1)\\n\\n element = self.locator_finder_by_xpath(f\\\"//*[contains(text(), '{index_name}')]\\\")\\n actions = ActionChains(self.driver)\\n # Move the mouse pointer to the element containing the text\\n actions.move_to_element(element)\\n # Perform a click action\\n actions.click().perform()\",\n \"def go_search_results(self, driver, searchlink):\\n self.go_and_assert(driver, searchlink, website)\",\n \"def testSelectSiteSearchFunctionality(self):\\n auth.checkIfUserIsLoggedIn(self.driver, 0, 'CRUDO')\\n auth.login(self.driver, config.users['CRUDO']['username'], config.users['CRUDO']['password'])\\n\\n try:\\n WebDriverWait(self.driver, 50).until(\\n EC.presence_of_element_located((By.ID, \\\"com.view.viewglass:id/search_image_view\\\")))\\n except TimeoutException:\\n raiseExceptions(\\\"Search field is missing\\\")\\n search = self.driver.find_element_by_id(\\\"com.view.viewglass:id/search_image_view\\\")\\n search.click()\\n search_text = self.driver.find_element_by_id(\\\"com.view.viewglass:id/search_site_edit_text\\\")\\n # search for the site and press ENTER\\n search_text.send_keys(config.sites['Default'])\\n # self.self.driver.press_keycode(66)\\n size = self.driver.find_element_by_id(\\\"com.view.viewglass:id/viewLogoLL\\\").size\\n location = self.driver.find_element_by_id(\\\"com.view.viewglass:id/viewLogoLL\\\").location\\n x = size['width'] / 2\\n y = location['y'] + size['height'] * 2\\n self.driver.tap([(x, y)])\\n if len(self.driver.find_elements(By.ID, \\\"com.view.viewglass:id/viewLogoLL\\\")) > 0:\\n y = location['y'] + size['height'] * 2.5\\n self.driver.tap([(x, y)])\\n else:\\n raiseExceptions(\\\"Search function did not return any results.\\\")\",\n \"def click_key(xpath, timeout=default_timeout):\\n logger.debug(f\\\"Clicking the element with XPATH {xpath}\\\")\\n start_time = time.time()\\n try:\\n try:\\n element = WebDriverWait(driver, timeout).until(\\n EC.presence_of_element_located((By.XPATH, xpath)))\\n except TimeoutException:\\n logger.warning(f\\\"Element with xpath {xpath} was not found within {timeout} seconds.\\\")\\n return False\\n\\n driver.execute_script(\\\"arguments[0].scrollIntoView(true);\\\", element)\\n \\n try:\\n element = WebDriverWait(driver, timeout - (time.time()-start_time)).until(\\n EC.element_to_be_clickable((By.XPATH, xpath)))\\n except TimeoutException:\\n logger.warning(f\\\"Element with xpath {xpath} was found but not clickable within {timeout} seconds.\\\")\\n return False \\n\\n while True:\\n try:\\n element.click()\\n break\\n except ElementClickInterceptedException as e:\\n if time.time() - start_time > timeout:\\n logger.warning(f\\\"Element with xpath {xpath} was found but obscured by another element.\\\")\\n logger.warning(f\\\"Selenium message: {e}\\\") # This exception actually contains useful information\\n return False\\n\\n return True\\n except StaleElementReferenceException:\\n # Account for situations where the element is present but gets overwritten with an identical element\\n # This can happen when switching function key menus, for example\\n logger.debug(\\\"Element became stale after we grabbed it. Restarting the click process.\\\")\\n return click_key(xpath, timeout=timeout - (start_time - time.time()))\",\n \"def search(self, term):\",\n \"def scroll_to_text(self,param,ignore_error_handle = False):\\n message = {};\\n text = param.get('text')\\n resourceid = param.get('resourceid')\\n instance = param.get('instance')\\n if instance is None:\\n instance = 0\\n step = ('scroll UI element \\\\'%s\\\\' to \\\\'%s\\\\' with instance \\\\'%s\\\\'')%(text,resourceid,instance);\\n try:\\n scrollResult = self.driver.scroll_element_to_text(resourceid,text,instance);\\n message = self.feedback.feedback_action_ok(step)\\n message['scroll'] = scrollResult;\\n except BaseException,e:\\n message = self.feedback.feedback_action_fail(step,str(e),ignore_error_handle);\\n message['scroll'] = False\\n\\n finally:\\n return message\",\n \"def termin_suchen(driver: webdriver.Chrome):\\n\\n driver.find_element_by_xpath(\\\"//button[contains(text(),'suchen')]\\\").click()\",\n \"def enter_text(self, text):\\n self.q(css='#fixture input').fill(text)\",\n \"def element_to_have_exact_text(self, target: ElementType, text: str, timeout: TimeoutType = DEFAULT_TIMEOUT):\\n\\n def has_exact_text_in_target():\\n target.get_web_element_by_timeout(timeout)\\n return target if text == target.text else False\\n\\n err_msg = f\\\"TimeoutException while waited {timeout} for the element {target.selector} \\\" \\\\\\n f\\\"to have exact text '{text}'. Actual text '{target.text}'\\\"\\n\\n return self.wait_fluently(has_exact_text_in_target, timeout, err_msg)\",\n \"def focus_and_input_text(\\n self, element_id: str, text: str, wait_time: Optional[float] = None\\n ):\\n sleeptime = wait_time or self.explicit_wait\\n self.set_focus(element_id)\\n self.input_text(element_id, text)\\n if sleeptime and sleeptime > 0:\\n time.sleep(sleeptime)\",\n \"def searchWikidata(input, type):\\n # Whenever the user types something in the searchbar open a session\\n if len(input) >= 1:\\n # The string with API wbsearchentities to suggestions to the user input\\n URL = \\\"https://www.wikidata.org/w/api.php?action=wbsearchentities&search=%s\\\" \\\\\\n \\\"&format=json&limit=5&formatversion=2&language=en&type=%s\\\" % (input, type)\\n with requests.Session() as S:\\n DATA = S.post(url=URL, headers={\\\"user-agent\\\": \\\"magic browser\\\", \\\"Content-Type\\\": \\\"application/json\\\"}).json()\\n\\n # Whenever a search entity is returned, do something\\n if len(DATA[\\\"search\\\"]) >= 1:\\n # Go through the DATA.json and append an entity label, id and description to a option list\\n option_list = []\\n for option in DATA[\\\"search\\\"]:\\n temp_str = \\\"\\\"\\n\\n try:\\n temp_str += option[\\\"label\\\"] + \\\" (\\\"\\n except Exception:\\n temp_str += \\\"|\\\"\\n\\n try:\\n temp_str += option[\\\"id\\\"] + \\\") | \\\"\\n except Exception:\\n temp_str += \\\"|\\\"\\n\\n try:\\n temp_str += option[\\\"description\\\"]\\n except Exception:\\n \\\"\\\"\\n\\n option_list.append(temp_str)\\n\\n # Creates a list with the suggested entities\\n return html.Ul([html.Li(temp_str) for temp_str in option_list])\\n\\n # If no results is returned do something\\n else:\\n return \\\"No results could be found\\\"\\n\\n # Do nothing when no input\\n else:\\n return \\\"\\\"\",\n \"def _jsclick(self, locator):\\n\\n self.selenium.wait_until_page_contains_element(locator)\\n self.selenium.wait_until_element_is_enabled(locator)\\n for should_retry in (True, False):\\n try:\\n # Setting the focus first seems to be required as of Spring'20\\n # (read: without it, tests started failing in that release). I\\n # suspect it's because there is a focusOut handler on form\\n # fields which need to be triggered for data to be accepted.\\n element = self.selenium.get_webelement(locator)\\n self.selenium.driver.execute_script(\\n \\\"arguments[0].focus(); arguments[0].click()\\\", element\\n )\\n return\\n except StaleElementReferenceException:\\n if should_retry:\\n time.sleep(1)\\n else:\\n raise\",\n \"def search_google(self, widget):\\n if not self.searchstring:\\n return\\n base_uri = \\\"https://www.google.com/search?q=%s\\\"\\n uri = base_uri % urllib.parse.quote(self.searchstring.encode(\\\"utf-8\\\"))\\n Gtk.show_uri_on_window(None, uri, Gdk.CURRENT_TIME)\",\n \"def on_searchButton_clicked(self):\\n self.__search()\",\n \"def test_IMDB_Search_TC_002_search_for_a_movie(self):\\n # to load a given URL in browser window\\n self.driver.get(self.base_url) \\n # to enter search term, we need to locate the search textbox\\n searchTextBox=self.driver.find_element_by_id(\\\"suggestion-search\\\")\\n # to clear any text in the search textbox\\n searchTextBox.clear()\\n # to enter the search term in the search textbox via send_keys() function\\n searchTextBox.send_keys(self.search_term)\\n # to search for the entered search term\\n searchTextBox.send_keys(Keys.RETURN)\\n # to see movie title element\\n searchMovieBox = self.driver.find_element_by_link_text(\\\"Silicon Valley\\\")\\n # to verify if the search results page loaded\\n self.assertIn(\\\"Find - IMDb\\\",self.driver.title)\\n # to verify if the search results page contains any results or no results were found.\\n self.assertNotIn(\\\"No results found.\\\",self.driver.page_source)\",\n \"def select(self, xpath, value=None, text=None, index=None):\\n field = webdriver.support.ui.Select(self.driver.find_element_by_xpath(xpath))\\n if value:\\n field.select_by_value(value)\\n elif text:\\n field.select_by_visible_text(text)\\n elif index:\\n field.select_by_index(index)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.661339","0.65298027","0.64589846","0.63079387","0.6279679","0.6225251","0.61082816","0.60499865","0.5844906","0.5839642","0.58275473","0.58186126","0.5792587","0.57632035","0.57194805","0.569059","0.568484","0.5681119","0.5595558","0.5590351","0.55692565","0.55624163","0.554438","0.55205745","0.551623","0.55135304","0.54787904","0.5475861","0.54727453","0.54540074","0.54386663","0.5417358","0.5415764","0.5415605","0.5393535","0.53868705","0.5346222","0.5341026","0.5340721","0.53400666","0.5317634","0.5305531","0.53046113","0.53005064","0.529075","0.52893984","0.527037","0.5265826","0.52650106","0.5261895","0.5257951","0.52564317","0.5252896","0.5249199","0.5245326","0.5244453","0.52270675","0.52230525","0.5216691","0.52130896","0.521023","0.52066314","0.52058744","0.51931196","0.5174897","0.51608944","0.51504457","0.5141444","0.51410913","0.51191187","0.5107944","0.5106094","0.51026857","0.50853205","0.5080845","0.50786906","0.50741714","0.5065861","0.5060576","0.5056677","0.5040457","0.5039795","0.5038932","0.5032778","0.50326324","0.5023096","0.50203097","0.5019302","0.5013886","0.5010803","0.5008967","0.50048226","0.50000733","0.49969506","0.4992531","0.4992411","0.49923998","0.49914157","0.49875963","0.49736655"],"string":"[\n \"0.661339\",\n \"0.65298027\",\n \"0.64589846\",\n \"0.63079387\",\n \"0.6279679\",\n \"0.6225251\",\n \"0.61082816\",\n \"0.60499865\",\n \"0.5844906\",\n \"0.5839642\",\n \"0.58275473\",\n \"0.58186126\",\n \"0.5792587\",\n \"0.57632035\",\n \"0.57194805\",\n \"0.569059\",\n \"0.568484\",\n \"0.5681119\",\n \"0.5595558\",\n \"0.5590351\",\n \"0.55692565\",\n \"0.55624163\",\n \"0.554438\",\n \"0.55205745\",\n \"0.551623\",\n \"0.55135304\",\n \"0.54787904\",\n \"0.5475861\",\n \"0.54727453\",\n \"0.54540074\",\n \"0.54386663\",\n \"0.5417358\",\n \"0.5415764\",\n \"0.5415605\",\n \"0.5393535\",\n \"0.53868705\",\n \"0.5346222\",\n \"0.5341026\",\n \"0.5340721\",\n \"0.53400666\",\n \"0.5317634\",\n \"0.5305531\",\n \"0.53046113\",\n \"0.53005064\",\n \"0.529075\",\n \"0.52893984\",\n \"0.527037\",\n \"0.5265826\",\n \"0.52650106\",\n \"0.5261895\",\n \"0.5257951\",\n \"0.52564317\",\n \"0.5252896\",\n \"0.5249199\",\n \"0.5245326\",\n \"0.5244453\",\n \"0.52270675\",\n \"0.52230525\",\n \"0.5216691\",\n \"0.52130896\",\n \"0.521023\",\n \"0.52066314\",\n \"0.52058744\",\n \"0.51931196\",\n \"0.5174897\",\n \"0.51608944\",\n \"0.51504457\",\n \"0.5141444\",\n \"0.51410913\",\n \"0.51191187\",\n \"0.5107944\",\n \"0.5106094\",\n \"0.51026857\",\n \"0.50853205\",\n \"0.5080845\",\n \"0.50786906\",\n \"0.50741714\",\n \"0.5065861\",\n \"0.5060576\",\n \"0.5056677\",\n \"0.5040457\",\n \"0.5039795\",\n \"0.5038932\",\n \"0.5032778\",\n \"0.50326324\",\n \"0.5023096\",\n \"0.50203097\",\n \"0.5019302\",\n \"0.5013886\",\n \"0.5010803\",\n \"0.5008967\",\n \"0.50048226\",\n \"0.50000733\",\n \"0.49969506\",\n \"0.4992531\",\n \"0.4992411\",\n \"0.49923998\",\n \"0.49914157\",\n \"0.49875963\",\n \"0.49736655\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72133875"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23495,"cells":{"query":{"kind":"string","value":"Open application on mobile device."},"document":{"kind":"string","value":"def start_app(self):\n app_xpath = '//android.widget.FrameLayout[@content-desc=\\\"{app}\\\"]/android.widget.ImageView'\n LOGGER.info('Starting app now!')\n tex = app_xpath.format(app=self.app_name)\n try:\n self.click_element(el_type='xpath', text=tex, handle_error=False)\n except NoSuchElementException:\n LOGGER.exception('Cannot find {app} on home screen of the phone!'.format(\n app=self.app_name))\n sys.exit(1)\n LOGGER.debug(\"{app} is opened on {name}\".format(\n app=self.app_name, name=self.mobile_name))\n time.sleep(5)\n self.set_scroll_length()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def open_mobile_application(self, platform):\n if platform == ANDROID:\n self.appium_lib.open_application(APPIUM_URL_ANDROID, platformName = APPIUM_DESIRED_CAPS['platformName'],\n deviceName = APPIUM_DESIRED_CAPS['udid'],\n app = APPIUM_DESIRED_CAPS['app'],\n appPackage = APPIUM_DESIRED_CAPS['appPackage'],\n appActivity = APPIUM_DESIRED_CAPS['appActivity'],\n noSign = APPIUM_DESIRED_CAPS['noSign'],\n fullReset = APPIUM_DESIRED_CAPS['fullReset'])\n self.appium_lib.wait_until_element_is_visible(RESULT)\n self.builtin_lib.sleep(1)\n else:\n self.builtin_lib.fail(\"Platform not correct\")\n raise AssertionError(\"Failed to open mobile application!\")\n self.current_driver = self.appium_lib._cache.current # type: WebDriver\n self.os = self.current_driver.capabilities['platformName']","def launch_app(self):\n os.system (\"adb shell am start -n com.tencent.mm/com.tencent.mm.ui.LauncherUI/\")\n time.sleep (5)","def open_app(device, package_name):\n\n device.shell('am start -n ' + package_name + '/' + package_name + \".modules.overview.screen\" +\n '.OverviewActivity')","def start_app(package, activity=None):\n G.DEVICE.start_app(package, activity)","def desktop_or_mobile(request):\n url_name = 'home.mobile' if request.MOBILE else 'home'\n return redirect_to(request, url_name, permanent=False)","def select_app_launcher_app(self, app_name):\n locator = lex_locators[\"app_launcher\"][\"app_link\"].format(app_name)\n self.open_app_launcher()\n self.selenium.wait_until_page_contains_element(locator, timeout=30)\n self.selenium.set_focus_to_element(locator)\n elem = self.selenium.get_webelement(locator)\n link = elem.find_element_by_xpath(\"../../..\")\n self.selenium.set_focus_to_element(link)\n link.click()\n self.wait_until_modal_is_closed()","def start_app(self, package, activity=None):\n return self.adb.start_app(package, activity)","def launch_intent():\n welcome_message = \"On which cloud would you like to launch Galaxy?\"\n return question(welcome_message).reprompt(help_text)","def open_camera__MAC(jarvis, s):\n os.system('open /Applications/Photo\\\\ Booth.app')","def open_url(self):\n QDesktopServices.openUrl(self.url)","def launch_an_app(appname,ui):\r\n ui = ui\r\n time.sleep(WAIT)\r\n \"\"\"Clicking on Launcher button\"\"\"\r\n ui.doDefault_on_obj('Launcher', False, role='button') \r\n time.sleep(WAIT)\r\n ui.doDefault_on_obj(name='Expand to all apps', role='button')\r\n time.sleep(WAIT)\r\n \"\"\"Launching an APK\"\"\"\r\n ui.doDefault_on_obj(appname, False, 'button') \r\n time.sleep(WAIT)","def open_in_web(self):\n self._client_api._open_in_web(url=self.platform_url)","def launchgame2Live(self, event):\n\n self.game2livebutton.Disable()\n\n deviceModel, deviceID = self.getDevices()\n listLength = len(deviceID)\n\n if not deviceModel or not deviceID:\n self.SetStatusText(\"No Android devices detected\")\n self.game2livebutton.Enable()\n return\n\n for i in range(listLength):\n self.SetStatusText(f\"Launching App3 on {deviceModel[i]} {i+1}/{listLength} to live\")\n response = subprocess.call(f\"adb -s {deviceID[i]} shell monkey -p com.atrox.app2.android -c android.intent.category.LAUNCHER 1\", creationflags=self.createNoWindow)\n # print(response)\n\n if response == 0:\n if listLength > 1:\n self.SetStatusText(f\"Finished Launching App3 on {listLength} devices to live\")\n else:\n self.SetStatusText(f\"Finished Launching App3 {listLength} device to live\")\n\n elif response != 0:\n self.SetStatusText(f\"Application not installed\")\n\n self.game2livebutton.Enable()","def launchServer(self, event, userinput):\n\n self.rentalbutton.Disable()\n deviceModel, deviceID = self.getDevices()\n\n if not deviceModel or not deviceID:\n self.SetStatusText(\"No Android devices detected\")\n self.rentalbutton.Enable()\n return\n\n listLength = len(deviceID)\n\n for i in range(listLength):\n self.SetStatusText(f\"Processing {deviceModel[i]} {i+1} out of {listLength}.\")\n subprocess.call(f\"adb -s {deviceID[i]} shell am force-stop com.company.App1.android\", creationflags=self.createNoWindow)\n subprocess.call(f\"adb -s {deviceID[i]} shell am force-stop com.company.App2.android\", creationflags=self.createNoWindow)\n subprocess.call(f\"adb -s {deviceID[i]} shell am start {userinput}\", creationflags=self.createNoWindow)\n\n if listLength > 1:\n self.SetStatusText(f\"Finished Launching {listLength} devices to {userinput}\")\n else:\n self.SetStatusText(f\"Finished Launching device to {userinput}\")","def launch_application(path) -> WebDriver:\n try:\n exp_cap = {\n \"deviceName\": \"WindowsPC\",\n \"app\": path}\n exp_session = webdriver.Remote(\n command_executor='http://127.0.0.1:4723',\n desired_capabilities=exp_cap)\n return exp_session\n except Exception as ex:\n logger.info(f':Error in launching app ERROR: {ex}')","def open_url(self, url):\n if url is None:\n return\n QDesktopServices.openUrl(QUrl(url))","def aisappium_open_application(self, remote_url, alias=None, **kwargs):\n index = AppiumLibrary.open_application(self, remote_url, alias, **kwargs)\n driver = self._current_application()\n oAppiumInfo = AtlasInfo(index, alias, driver, remote_url)\n return oAppiumInfo","def open(self, device_id):\n self._js[device_id].open()","def start(self):\n\n #print 'start tcp port 8080 forwarding'\n subprocess.call(r'%s forward tcp:%d tcp:8080'%(self.adbCmd,self.port),shell=True)\n\n\n # this is not mandatory as we already killed adb server, but this could \n # decrease the webview created in andriod server application. maybe\n # it's a bug to create one webview per launch of app?\n #print 'stop existing android server by sending back key'\n for i in xrange(4):\n subprocess.call(r'%s shell input keyevent 4'%self.adbCmd,shell=True)\n\n #print 'start android server activity'\n output=subprocess.check_output(r'%s shell am start -n %s'%(self.adbCmd,\n Service.ANDROID_DRIVER_CLIENT_APP_CMP),\n stderr=subprocess.STDOUT,shell=True).split()\n if len(output)> 5: #if app not installed, there would be error messages\n raise WebDriverException(\"\"\"AndroidDriver needs to be installed on device.\n Download android-server-2.x.apk from\n http://code.google.com/p/selenium/downloads/list\"\"\")\n # wait for WebDriver Client to be launched completely\n time.sleep(2)\n print \"AndroidDriver started on device %s\" % repr(self.device)","def launchgame1Live(self, event):\n\n self.game1livebutton.Disable()\n\n deviceModel, deviceID = self.getDevices()\n listLength = len(deviceID)\n\n if not deviceModel or not deviceID:\n self.SetStatusText(\"No Android devices detected\")\n self.game1livebutton.Enable()\n return\n\n for i in range(listLength):\n self.SetStatusText(f\"Launching App1 3 on {deviceModel[i]} {i+1}/{listLength} to live\")\n response = subprocess.call(f\"adb -s {deviceID[i]} shell monkey -p com.atrox.app1 -c android.intent.category.LAUNCHER 1\", creationflags=self.createNoWindow)\n\n if response == 0:\n if listLength > 1:\n self.SetStatusText(f\"Finished Launching App1 on {listLength} devices to live\")\n else:\n self.SetStatusText(f\"Finished Launching App1 {listLength} device to live\")\n elif response != 0:\n self.SetStatusText(f\"Application not installed\")\n\n self.game1livebutton.Enable()","def open_in_note_app(app: str, path: str):\n call([app, path])","async def launch_app(self, bundle_id: str) -> None:\n await self.relay(\"launch_app\")(bundle_id)","def start_app(self, package: str, activity: Optional[str] = None):\n if not activity:\n cmds = ['monkey', '-p', package, '-c', 'android.intent.category.LAUNCHER', '1']\n else:\n cmds = ['am', 'start', '-n', f'{package}/{package}.{activity}']\n self.shell(cmds)","def _open_magnet(ctx, link):\n\n system = platform.system().lower()\n if system == 'darwin':\n webbrowser.open(link)\n elif system == 'linux':\n subprocess.Popen(['xdg-open', link]).wait()\n else:\n os.startfile(link)","def ensure_application_is_open(self, platform):\n self.builtin_lib.sleep(0.2)\n retries_left = MAX_RETRIES\n while retries_left and not self._is_application_alive():\n self.appium_lib.close_all_applications()\n self.open_mobile_application(platform)\n retries_left -= retries_left\n self.builtin_lib.log(\"Retries left %s\" % retries_left)\n if not retries_left >= 0:\n raise AssertionError(\"Failed to ensure application open!\")","def openurl(device, url):\n command = 'openurl \"%s\" \"%s\"' % (device.udid, url)\n _run_command(command)","def mobile(request):\n MOBILE_AGENT_RE = re.compile(\n r\".*(iphone|mobile|androidtouch)\", re.IGNORECASE)\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\n return True\n else:\n return False","def start(self, device, platform, version, app, package, activity):\n self.initialize(device, platform, version, app, package, activity)","def open(self, event=None, url=None):\n url = url or self.server.url\n try:\n import webbrowser\n webbrowser.open(url)\n except ImportError: # pre-webbrowser.py compatibility\n if sys.platform == 'win32':\n os.system('start \"%s\"' % url)\n elif sys.platform == 'mac':\n try:\n import ic\n ic.launchurl(url)\n except ImportError: pass\n else:\n rc = os.system('netscape -remote \"openURL(%s)\" &' % url)\n if rc: os.system('netscape \"%s\" &' % url)","def switchToAppInstaller(dev):\n print('Switching to app install mode')\n SonyExtCmdCamera(dev).switchToAppInstaller()","def open_application(self):\n __index = self.ui.comboBox.currentIndex()\n # print(self.plugins.name_application[__index])\n self.plugins.application(self, __index)\n self.hide()","def load_app(self):\n self.driver.wdvr.start_activity(PACKAGE.DROPBOX, LAUNCH_ACTIVITY.DROPBOX_HOME, app_wait_activity=WAIT_ACTIVITY.DROPBOX)","def openContactUrl(self):\r\n url = QUrl(\"http://freeseer.readthedocs.org/en/latest/contact.html\")\r\n QDesktopServices.openUrl(url)","def enter(self):\n self.logger.debug(\"Launch email.\")\n if self.device(description=self.appconfig(\"navigation\")).wait.exists(timeout=self.timeout):\n return True\n self.start_app(\"Email\")\n if self.device(description=self.appconfig(\"navigation\")).wait.exists(timeout=self.timeout):\n return True\n else:\n self.logger.debug('Launch eamil fail')\n return False","def send_otp_to_primary_mobile(otp, mobile):\n print('Sending otp to mobile: ', otp, mobile)","def openSensel():\n handle = None\n (error, device_list) = sensel.getDeviceList()\n if device_list.num_devices != 0:\n (error, handle) = sensel.openDeviceByID(device_list.devices[0].idx)\n return handle","def close_app(self):\n os.system ('adb shell am force-stop com.tencent.mm')","def open(self, deviceID):\r\n \r\n return self._performAction(deviceID, _API_DEVICE_ACTION_OPEN)","def do_start(self, str_arg):\n try:\n # self.adbc.startActivity(validateString(str_arg))\n # the above approach failed in unittest complaining device is offline, weird...\n return self.runAdbCmd('shell am start -n', validateString(str_arg))\n except RuntimeError:\n self.resultFlag = False\n if DEBUG:\n traceback.print_exc()","def smartx_cmd(ctx):\n webbrowser.open(\"https://smartx.ont.io/\")","def startAndroidDeviceMonitor(self, event):\n try:\n os.startfile(r\"C:\\Users\\sam_JOYCE\\AppData\\Local\\Android\\Sdk\\tools\\lib\\monitor-x86_64\\monitor.exe\")\n self.SetStatusText(f\"Successfully started Android Device Monitor\")\n except FileNotFoundError:\n self.SetStatusText(f\"Not Found. Please install the Android SDK\")","def go_to_home_application(self):\n self.parent.show()\n self.hide()","def open_audible_com(self):\n self.driver.get(\"http://www.audible.com\")\n\n self._go_to_audible_com_if_on_uk_page()","def launchMinipadServer(self):\n return","def open(alias):\n s = db.Series.alias_lookup(alias)\n click.launch(s.url)","def open_device_dialog(self):\n res, device = DeviceDialog.get_device(self.indexer)\n if res and device:\n self.serial = device.serial\n if self.serial:\n caps_str = None\n self.open_device(self.serial, caps_str)","def startapp(self, command):\n e = self.emu\n e.alt(\"F2\")\n e.shortwait()\n e.clickat(self.screen.center)\n e.shortwait()\n e.type(command + \"\\n\")\n e.longwait()","def open_link(self):\n try:\n # webbrowser.open(self.url) # if you are on Windows OS\n webbrowser.get('safari').open_new_tab(self.url) # if you are on Mac OS\n except(AttributeError):\n self.ids.label.text = self.error_msg","def home():\n G.DEVICE.home()","def platform_start(self):\n self.platform.start()","def install_app(device, path):\n command = 'install \"%s\" \"%s\"' % (device.udid, path)\n _run_command(command)","def view_app(request, pk):\n\n app = get_object_or_404(MacOSApp, pk=pk)\n\n context = {'app': app}\n return render(request, 'mdm/app_detail.html', context)","def startapp():","def open_in_web(self, model=None, model_id=None):\n if model is not None:\n model.open_in_web()\n elif model_id is not None:\n self._client_api._open_in_web(url=self.platform_url + '/' + str(model_id) + '/main')\n else:\n self._client_api._open_in_web(url=self.platform_url)","def click_nav_desktops_mac(self):\n self.click_nav_desktops()\n self.driver.find_element(*BasePageLocators.MAC).click()\n return ProductsPage(self.driver)","def launch_app(item,terminal=False):\n try:\n if terminal:\n subprocess.Popen(['/bin/terminal',item])\n else:\n subprocess.Popen(shlex.split(item))\n except:\n pass","def launch (self):\n path = \"\"\n os.system(path + 'kidlogger_user.exe')","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def aboutThermAP():\n import webbrowser\n url = os.path.join(progpath, \"ThermAP_presentation.pdf\")\n if platform.system() == \"Darwin\":\n webbrowser._browsers['safari'][1].open(url)\n else:\n webbrowser.open(url)","def open_link(self) -> None:\n\n webbrowser.open_new(self.link)","def start_app(self, App):\n self.app = App(device=self.device,\n simulator=self.simulator)\n self.app.exec_()\n self.app = TimeWordsApp(device=self.device,\n simulator=self.simulator)","def try_continue_to_openManage_mobile():\r\n msg, status = \"\", True\r\n try:\r\n if g.platform == 'android':\r\n\r\n 'Getting y_elem as destination element'\r\n y_elem = ui_controls.ui_element(get_obj_identifier('common_widget_scrollview'))\r\n\r\n 'Getting x_elem as source element'\r\n x_elem = ui_controls.ui_element(get_obj_identifier('demo_tryDemoMode_btn'))\r\n\r\n 'Scroll the element from x elem to y elem'\r\n flag1 = ui_controls.scroll_element(x_elem, y_elem)\r\n sleep(3)\r\n\r\n 'Click on Continue to OMM button'\r\n flag2 = ui_controls.button(get_obj_identifier('demo_continueToOmm_btn'))\r\n\r\n status = False if not (flag1 and flag2) else True\r\n else:\r\n sleep(3)\r\n flag1=ui_controls.swipe_up()\r\n sleep(3)\r\n 'Click on Continue to OMM button in IOS'\r\n flag2 = ui_controls.button(get_obj_identifier('demo_continueToOmm_btn'))\r\n sleep(4)\r\n \r\n status = False if not (flag1 and flag2) else True\r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def createApp(self):\n app = self.app\n window = self.window\n window.show()\n app.exec()","def show(filepath):\n if os.name == 'mac': subprocess.call(('open', filepath))\n elif os.name == 'nt': os.startfile(filepath)","def openSite(url):\n\timport webbrowser\n\twebbrowser.open('http://www.' + url + '.com', 2)","def open_settings(self):\n self.android_device_driver.adb.exec_adb_cmd(\n \"shell am start -a android.settings.SETTINGS\").wait()","def runApp(self, theEmulator, theApkObj):\n # Clear log\n self.log.info('Clear log')\n theEmulator.clearLog()\n \n # Install app\n self.log.info('- Installing app...')\n \n numRetries = 0\n while True:\n numRetries += 1\n self.log.info('Try %d times to install app' % numRetries)\n try:\n theEmulator.installApp(theApkObj.get_filename())\n break\n except EmulatorClientError, ecErr:\n errorOccuredFlag = True\n if ecErr.getCode() == EmulatorClientError.INSTALLATION_ERROR_ALREADY_EXISTS:\n break\n if ecErr.getCode == EmulatorClientError.GENERAL_INSTALLATION_ERROR:\n self.log.error('Can\\'t install app!')\n \n elif ecErr.getCode() == EmulatorClientError.INSTALLATION_ERROR_SYSTEM_NOT_RUNNING:\n if numRetries == 4:\n self.log.info('Number of maximum retries reached, abort installation')\n else:\n # Wait and retry\n errorOccuredFlag = False\n waitTime = numRetries * 10\n self.log.info('Installation failed as system might not be running. Wait for %dsec and try again' % waitTime)\n time.sleep(waitTime)\n continue\n if errorOccuredFlag: # Error occured\n # Return\n return False\n \n # Start logcat redirect\n self.logcatRedirectFile = DynamicAnalyzerConst.LOGCAT_REDIRECT_FILE\n theEmulator.startLogcatRedirect(self.logcatRedirectFile, 4096)\n \n # Switch on taint tracking\n theEmulator.changeGlobalTaintLogState('1', True)\n \n # Run main activity\n try:\n mainActivity = theApkObj.get_main_activity()\n if mainActivity:\n self.log.info('Start main activity %s' % mainActivity)\n theEmulator.startActivity(theApkObj.get_package(), mainActivity)\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_ACTIVITY_TIME)\n else:\n self.log.info('No MainActivity found!')\n except Exception,ecErr:\n self.log.exce(traceback.format_exc())\n \n # Capture Screen\n rawFile = os.path.join(self.decompressPath, 'raw.tmp')\n destFile = os.path.join(self.decompressPath, 'screenshot')\n ffmpeg = os.path.join(self.mainDir, DynamicAnalyzerConst.FFMPEG_PATH)\n self._captureScreen(theEmulator, rawFile, destFile, ffmpeg)\n \n # Sleep for a little time to capture screen\n time.sleep(2)\n \n self.log.info('Start all services...')\n try:\n for service in theApkObj.get_services():\n self.log.info('Start service %s' % service)\n theEmulator.startService(theApkObj.get_package(), service)\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_SERVICE_TIME)\n except EmulatorClientError, ecErr:\n self.log.exce(traceback.format_exc())\n \n self.log.info('Start all receivers...')\n try:\n for receiver in theApkObj.get_receivers():\n self.log.info('Start receiver %s' % receiver)\n theEmulator.startReceiver(theApkObj.get_package(), receiver)\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_SERVICE_TIME)\n except EmulatorClientError, ecErr:\n self.log.exce(traceback.format_exc())\n \n return True","def open_program(path):\r\n os.startfile(path)","def run(self, url=''):\n if url:\n webbrowser.open(url)","def open(self):\n self._command = \"open\"","def on_OpenExplorer_clicked(self):\n # TODO: not implemented yet\n #raise NotImplementedError\n\n url=\"http://kfc.matrix.io\"\n\n self.browser.openurl(url)\n self.OnlyDisplay(f\"start {url}\")\n #MATRIXWebutil.open_new(url)\n #MATRIXWebutil.open_new_tab(url)","def start(self):\n\n self.app.go()","def do_device(self, args):\n self.device_command.cmdloop(\"Enter to device mode\")","def open_app_launcher(self, retry=True):\n\n self._jsclick(\"sf:app_launcher.button\")\n self._jsclick(\"sf:app_launcher.view_all\")\n self.wait_until_modal_is_open()\n try:\n # the modal may be open, but not yet fully rendered\n # wait until at least one link appears. We've seen that sometimes\n # the dialog hangs prior to any links showing up\n self.selenium.wait_until_element_is_visible(\n \"xpath://ul[contains(@class, 'al-modal-list')]//li\"\n )\n\n except Exception as e:\n # This should never happen, yet it does. Experience has\n # shown that sometimes (at least in spring '20) the modal\n # never renders. Refreshing the modal seems to fix it.\n if retry:\n self.builtin.log(\n f\"caught exception {e} waiting for app launcher; retrying\", \"DEBUG\"\n )\n self.selenium.press_keys(\"sf:modal.is_open\", \"ESCAPE\")\n self.wait_until_modal_is_closed()\n self.open_app_launcher(retry=False)\n else:\n self.builtin.log(\n f\"caught exception waiting for app launcher; not retrying\", \"DEBUG\"\n )\n raise","def open(self, app, pane = None, **args):\n\t\tpass","def open_web_browser(whac_config: WhacConfig) -> None:\n if whac_config.open_web_browser:\n browser = webbrowser.get('chrome')\n browser.open('http://localhost:' + str(whac_config.host_port), new=2, autoraise=True)","def goHome():\n\t#Go to pod home\n\tif screen.lastScreen in screen.protectedScreens:\n\t\tpodScreen.show()\n\telse:\n\t\tsplashScreen.show()","def connect_app(self, sid):\r\n return applications.ConnectApp(self, sid)","def open_url(self):\n self.window = QMainWindow()\n self.ui_linkreader = Ui_LinkReader()\n self.ui_linkreader.setup_ui(self.window)\n self.ui_linkreader.pushButton.setDefault(True)\n self.window.setFixedSize(self.window.width(), self.window.height())\n self.ui_linkreader.pushButton.clicked.connect(self.process_url)\n self.window.show()","def install(filepath, **kwargs):\n return G.DEVICE.install_app(filepath, **kwargs)","def start():\r\n\r\n userName = userLogin.login()\r\n runApp(userName)","def open(url):\r\n webbrowser.open(url)","def cmd_start(self, app_name=None):\n rc = self.socket_command_with_project('start', app_name)\n return rc","def play_btn_push(self):\n try:\n pl_name = self.pl_line_edit.text().replace(\" \", \"_\")\n path = os.path.abspath(\"Playlists/\"+ pl_name+\".m3u\")\n\n #if sys.platform == \"linux\" or sys.platform == \"linux2\":\n #print(\"linux\")\n\n if sys.platform == \"darwin\":\n subprocess.call([\"open\", path])\n\n elif sys.platform == \"win32\":\n os.startfile(path)\n except:\n QMessageBox.about(self, \"OS not recognized\",\n 'Could not recognize operating system.')","def open_in_browser(self):\n webbrowser.open(self.url)","def enable_mobile(self, android_package: str = None, android_activity: str = None, device_serial: str = None):\n if not android_package:\n raise AttributeError(\"android_package must be passed in\")\n self.mobile_options = {\n \"androidPackage\": android_package\n }\n if android_activity:\n self.mobile_options[\"androidActivity\"] = android_activity\n if device_serial:\n self.mobile_options[\"androidDeviceSerial\"] = device_serial","def openQrApp(self):\n self.qrApp_Window = QtWidgets.QDialog()\n self.openQrApp_ui = Ui_qrReaderApp()\n self.openQrApp_ui.setupUi(self.qrApp_Window)\n self.qrApp_Window.show()","def open_target (tgt):\n if sys.platform == \"darwin\":\n #\n # on OSX\n #\n open_exe = \"open\"\n elif 'DISPLAY'in os.environ:\n #\n # on Linux/Un*x\n #\n open_exe = \"xdg-open\"\n else:\n #\n # do nothing on other platforms\n #\n return\n try:\n pb = subprocess.Popen ([open_exe, tgt],\n stdout=open(\"/dev/null\", \"w\"),\n stderr=open(\"/dev/null\", \"w\"))\n pb.wait ( )\n except OSError:\n logging.warning (\"Could not open [%s]\" % tgt)\n else:\n if pb.returncode != 0:\n logging.warning (\"Could not open [%s]\" % tgt)","def getWebDriverInstance(self):\n #baseURL = \"https://qa-test.avenuecode.com/\"\n if self.device == \"ios_mobile\":\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n #return driver\n #driver.get(baseURL)\n\n else:\n print(\"Hello\")\n # Setting Driver Implicit Time out for An Element\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n return self.driver\n # Maximize the window\n #driver.maximize_window()\n # Loading browser with App URL\n #driver.get(baseURL)\n #return driver","def web():\n env['remote_port'] = env['port_map']['8000']\n\n sys.stdout.write('Launching browser on remote port %(remote_port)s\\n' % env)\n\n run('open http://%(relay_server)s:%(remote_port)s' % env)","def open_browser(url):\n import webbrowser\n webbrowser.open_new(url)","def open(self) -> None:\n if not self.__opened:\n if self.path is None:\n self.path = HID.enumerate_devices(self.vendor_id)[0]\n self.device.open_path(self.path)\n self.device.set_nonblocking(True)\n self.__opened = True","def check_mobile(request):\n MOBILE_AGENT_RE=re.compile(r\".*(iphone|mobile|androidtouch)\",re.IGNORECASE)\n\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\n return True\n else:\n return False","def open(self):\n if self._connected:\n try:\n self.native.find_prompt()\n except: # noqa E722 pylint: disable=bare-except\n self._connected = False\n\n if not self._connected:\n self.native = ConnectHandler(\n device_type=\"cisco_asa\",\n ip=self.host,\n username=self.username,\n password=self.password,\n port=self.port,\n global_delay_factor=self.global_delay_factor,\n secret=self.secret,\n verbose=False,\n )\n self._connected = True\n\n log.debug(\"Host %s: Connection to controller was opened successfully.\", self.host)","def open_database(app):\n app.status.message(\"Opening DICOM folder..\")\n path = app.dialog.directory(\"Select a DICOM folder\")\n if path == '':\n app.status.message('') \n return\n app.status.cursorToHourglass()\n app.close()\n app.open(path)\n app.status.hide()\n app.status.cursorToNormal()","def open_top():\n _open_url_path('')","def launch_app(simulator_name, bundle_id):\n logging.info(\"Launching app {BUNDLE_ID} on simulator '{SIMULATOR}'...\".format(BUNDLE_ID=bundle_id, SIMULATOR=simulator_name))\n\n try:\n p = subprocess.Popen(\n \"xcrun simctl launch '{SIMULATOR}' '{BUNDLE_ID}'\".format(SIMULATOR=simulator_name, BUNDLE_ID=bundle_id),\n shell=True,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n universal_newlines=True\n )\n output = p.communicate()[0].rstrip()\n\n app_pid = int(str(output.strip()).split(\" \")[1])\n logging.info(\"PID of launched application: [{PID}]\".format(PID=app_pid))\n\n except Exception as e:\n logging.error(\"Launching the APP failed with error '{ERROR}'\".format(ERROR=e))\n return None\n\n logging.info(\"Application launched successfuly!\")\n return app_pid","def onCaptureMobileLinkClicked(self, linkId=None):\n self.LinkMobileMacro.emit()","def open_url(self, url):\n\n self.driver.get(url)"],"string":"[\n \"def open_mobile_application(self, platform):\\n if platform == ANDROID:\\n self.appium_lib.open_application(APPIUM_URL_ANDROID, platformName = APPIUM_DESIRED_CAPS['platformName'],\\n deviceName = APPIUM_DESIRED_CAPS['udid'],\\n app = APPIUM_DESIRED_CAPS['app'],\\n appPackage = APPIUM_DESIRED_CAPS['appPackage'],\\n appActivity = APPIUM_DESIRED_CAPS['appActivity'],\\n noSign = APPIUM_DESIRED_CAPS['noSign'],\\n fullReset = APPIUM_DESIRED_CAPS['fullReset'])\\n self.appium_lib.wait_until_element_is_visible(RESULT)\\n self.builtin_lib.sleep(1)\\n else:\\n self.builtin_lib.fail(\\\"Platform not correct\\\")\\n raise AssertionError(\\\"Failed to open mobile application!\\\")\\n self.current_driver = self.appium_lib._cache.current # type: WebDriver\\n self.os = self.current_driver.capabilities['platformName']\",\n \"def launch_app(self):\\n os.system (\\\"adb shell am start -n com.tencent.mm/com.tencent.mm.ui.LauncherUI/\\\")\\n time.sleep (5)\",\n \"def open_app(device, package_name):\\n\\n device.shell('am start -n ' + package_name + '/' + package_name + \\\".modules.overview.screen\\\" +\\n '.OverviewActivity')\",\n \"def start_app(package, activity=None):\\n G.DEVICE.start_app(package, activity)\",\n \"def desktop_or_mobile(request):\\n url_name = 'home.mobile' if request.MOBILE else 'home'\\n return redirect_to(request, url_name, permanent=False)\",\n \"def select_app_launcher_app(self, app_name):\\n locator = lex_locators[\\\"app_launcher\\\"][\\\"app_link\\\"].format(app_name)\\n self.open_app_launcher()\\n self.selenium.wait_until_page_contains_element(locator, timeout=30)\\n self.selenium.set_focus_to_element(locator)\\n elem = self.selenium.get_webelement(locator)\\n link = elem.find_element_by_xpath(\\\"../../..\\\")\\n self.selenium.set_focus_to_element(link)\\n link.click()\\n self.wait_until_modal_is_closed()\",\n \"def start_app(self, package, activity=None):\\n return self.adb.start_app(package, activity)\",\n \"def launch_intent():\\n welcome_message = \\\"On which cloud would you like to launch Galaxy?\\\"\\n return question(welcome_message).reprompt(help_text)\",\n \"def open_camera__MAC(jarvis, s):\\n os.system('open /Applications/Photo\\\\\\\\ Booth.app')\",\n \"def open_url(self):\\n QDesktopServices.openUrl(self.url)\",\n \"def launch_an_app(appname,ui):\\r\\n ui = ui\\r\\n time.sleep(WAIT)\\r\\n \\\"\\\"\\\"Clicking on Launcher button\\\"\\\"\\\"\\r\\n ui.doDefault_on_obj('Launcher', False, role='button') \\r\\n time.sleep(WAIT)\\r\\n ui.doDefault_on_obj(name='Expand to all apps', role='button')\\r\\n time.sleep(WAIT)\\r\\n \\\"\\\"\\\"Launching an APK\\\"\\\"\\\"\\r\\n ui.doDefault_on_obj(appname, False, 'button') \\r\\n time.sleep(WAIT)\",\n \"def open_in_web(self):\\n self._client_api._open_in_web(url=self.platform_url)\",\n \"def launchgame2Live(self, event):\\n\\n self.game2livebutton.Disable()\\n\\n deviceModel, deviceID = self.getDevices()\\n listLength = len(deviceID)\\n\\n if not deviceModel or not deviceID:\\n self.SetStatusText(\\\"No Android devices detected\\\")\\n self.game2livebutton.Enable()\\n return\\n\\n for i in range(listLength):\\n self.SetStatusText(f\\\"Launching App3 on {deviceModel[i]} {i+1}/{listLength} to live\\\")\\n response = subprocess.call(f\\\"adb -s {deviceID[i]} shell monkey -p com.atrox.app2.android -c android.intent.category.LAUNCHER 1\\\", creationflags=self.createNoWindow)\\n # print(response)\\n\\n if response == 0:\\n if listLength > 1:\\n self.SetStatusText(f\\\"Finished Launching App3 on {listLength} devices to live\\\")\\n else:\\n self.SetStatusText(f\\\"Finished Launching App3 {listLength} device to live\\\")\\n\\n elif response != 0:\\n self.SetStatusText(f\\\"Application not installed\\\")\\n\\n self.game2livebutton.Enable()\",\n \"def launchServer(self, event, userinput):\\n\\n self.rentalbutton.Disable()\\n deviceModel, deviceID = self.getDevices()\\n\\n if not deviceModel or not deviceID:\\n self.SetStatusText(\\\"No Android devices detected\\\")\\n self.rentalbutton.Enable()\\n return\\n\\n listLength = len(deviceID)\\n\\n for i in range(listLength):\\n self.SetStatusText(f\\\"Processing {deviceModel[i]} {i+1} out of {listLength}.\\\")\\n subprocess.call(f\\\"adb -s {deviceID[i]} shell am force-stop com.company.App1.android\\\", creationflags=self.createNoWindow)\\n subprocess.call(f\\\"adb -s {deviceID[i]} shell am force-stop com.company.App2.android\\\", creationflags=self.createNoWindow)\\n subprocess.call(f\\\"adb -s {deviceID[i]} shell am start {userinput}\\\", creationflags=self.createNoWindow)\\n\\n if listLength > 1:\\n self.SetStatusText(f\\\"Finished Launching {listLength} devices to {userinput}\\\")\\n else:\\n self.SetStatusText(f\\\"Finished Launching device to {userinput}\\\")\",\n \"def launch_application(path) -> WebDriver:\\n try:\\n exp_cap = {\\n \\\"deviceName\\\": \\\"WindowsPC\\\",\\n \\\"app\\\": path}\\n exp_session = webdriver.Remote(\\n command_executor='http://127.0.0.1:4723',\\n desired_capabilities=exp_cap)\\n return exp_session\\n except Exception as ex:\\n logger.info(f':Error in launching app ERROR: {ex}')\",\n \"def open_url(self, url):\\n if url is None:\\n return\\n QDesktopServices.openUrl(QUrl(url))\",\n \"def aisappium_open_application(self, remote_url, alias=None, **kwargs):\\n index = AppiumLibrary.open_application(self, remote_url, alias, **kwargs)\\n driver = self._current_application()\\n oAppiumInfo = AtlasInfo(index, alias, driver, remote_url)\\n return oAppiumInfo\",\n \"def open(self, device_id):\\n self._js[device_id].open()\",\n \"def start(self):\\n\\n #print 'start tcp port 8080 forwarding'\\n subprocess.call(r'%s forward tcp:%d tcp:8080'%(self.adbCmd,self.port),shell=True)\\n\\n\\n # this is not mandatory as we already killed adb server, but this could \\n # decrease the webview created in andriod server application. maybe\\n # it's a bug to create one webview per launch of app?\\n #print 'stop existing android server by sending back key'\\n for i in xrange(4):\\n subprocess.call(r'%s shell input keyevent 4'%self.adbCmd,shell=True)\\n\\n #print 'start android server activity'\\n output=subprocess.check_output(r'%s shell am start -n %s'%(self.adbCmd,\\n Service.ANDROID_DRIVER_CLIENT_APP_CMP),\\n stderr=subprocess.STDOUT,shell=True).split()\\n if len(output)> 5: #if app not installed, there would be error messages\\n raise WebDriverException(\\\"\\\"\\\"AndroidDriver needs to be installed on device.\\n Download android-server-2.x.apk from\\n http://code.google.com/p/selenium/downloads/list\\\"\\\"\\\")\\n # wait for WebDriver Client to be launched completely\\n time.sleep(2)\\n print \\\"AndroidDriver started on device %s\\\" % repr(self.device)\",\n \"def launchgame1Live(self, event):\\n\\n self.game1livebutton.Disable()\\n\\n deviceModel, deviceID = self.getDevices()\\n listLength = len(deviceID)\\n\\n if not deviceModel or not deviceID:\\n self.SetStatusText(\\\"No Android devices detected\\\")\\n self.game1livebutton.Enable()\\n return\\n\\n for i in range(listLength):\\n self.SetStatusText(f\\\"Launching App1 3 on {deviceModel[i]} {i+1}/{listLength} to live\\\")\\n response = subprocess.call(f\\\"adb -s {deviceID[i]} shell monkey -p com.atrox.app1 -c android.intent.category.LAUNCHER 1\\\", creationflags=self.createNoWindow)\\n\\n if response == 0:\\n if listLength > 1:\\n self.SetStatusText(f\\\"Finished Launching App1 on {listLength} devices to live\\\")\\n else:\\n self.SetStatusText(f\\\"Finished Launching App1 {listLength} device to live\\\")\\n elif response != 0:\\n self.SetStatusText(f\\\"Application not installed\\\")\\n\\n self.game1livebutton.Enable()\",\n \"def open_in_note_app(app: str, path: str):\\n call([app, path])\",\n \"async def launch_app(self, bundle_id: str) -> None:\\n await self.relay(\\\"launch_app\\\")(bundle_id)\",\n \"def start_app(self, package: str, activity: Optional[str] = None):\\n if not activity:\\n cmds = ['monkey', '-p', package, '-c', 'android.intent.category.LAUNCHER', '1']\\n else:\\n cmds = ['am', 'start', '-n', f'{package}/{package}.{activity}']\\n self.shell(cmds)\",\n \"def _open_magnet(ctx, link):\\n\\n system = platform.system().lower()\\n if system == 'darwin':\\n webbrowser.open(link)\\n elif system == 'linux':\\n subprocess.Popen(['xdg-open', link]).wait()\\n else:\\n os.startfile(link)\",\n \"def ensure_application_is_open(self, platform):\\n self.builtin_lib.sleep(0.2)\\n retries_left = MAX_RETRIES\\n while retries_left and not self._is_application_alive():\\n self.appium_lib.close_all_applications()\\n self.open_mobile_application(platform)\\n retries_left -= retries_left\\n self.builtin_lib.log(\\\"Retries left %s\\\" % retries_left)\\n if not retries_left >= 0:\\n raise AssertionError(\\\"Failed to ensure application open!\\\")\",\n \"def openurl(device, url):\\n command = 'openurl \\\"%s\\\" \\\"%s\\\"' % (device.udid, url)\\n _run_command(command)\",\n \"def mobile(request):\\n MOBILE_AGENT_RE = re.compile(\\n r\\\".*(iphone|mobile|androidtouch)\\\", re.IGNORECASE)\\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\\n return True\\n else:\\n return False\",\n \"def start(self, device, platform, version, app, package, activity):\\n self.initialize(device, platform, version, app, package, activity)\",\n \"def open(self, event=None, url=None):\\n url = url or self.server.url\\n try:\\n import webbrowser\\n webbrowser.open(url)\\n except ImportError: # pre-webbrowser.py compatibility\\n if sys.platform == 'win32':\\n os.system('start \\\"%s\\\"' % url)\\n elif sys.platform == 'mac':\\n try:\\n import ic\\n ic.launchurl(url)\\n except ImportError: pass\\n else:\\n rc = os.system('netscape -remote \\\"openURL(%s)\\\" &' % url)\\n if rc: os.system('netscape \\\"%s\\\" &' % url)\",\n \"def switchToAppInstaller(dev):\\n print('Switching to app install mode')\\n SonyExtCmdCamera(dev).switchToAppInstaller()\",\n \"def open_application(self):\\n __index = self.ui.comboBox.currentIndex()\\n # print(self.plugins.name_application[__index])\\n self.plugins.application(self, __index)\\n self.hide()\",\n \"def load_app(self):\\n self.driver.wdvr.start_activity(PACKAGE.DROPBOX, LAUNCH_ACTIVITY.DROPBOX_HOME, app_wait_activity=WAIT_ACTIVITY.DROPBOX)\",\n \"def openContactUrl(self):\\r\\n url = QUrl(\\\"http://freeseer.readthedocs.org/en/latest/contact.html\\\")\\r\\n QDesktopServices.openUrl(url)\",\n \"def enter(self):\\n self.logger.debug(\\\"Launch email.\\\")\\n if self.device(description=self.appconfig(\\\"navigation\\\")).wait.exists(timeout=self.timeout):\\n return True\\n self.start_app(\\\"Email\\\")\\n if self.device(description=self.appconfig(\\\"navigation\\\")).wait.exists(timeout=self.timeout):\\n return True\\n else:\\n self.logger.debug('Launch eamil fail')\\n return False\",\n \"def send_otp_to_primary_mobile(otp, mobile):\\n print('Sending otp to mobile: ', otp, mobile)\",\n \"def openSensel():\\n handle = None\\n (error, device_list) = sensel.getDeviceList()\\n if device_list.num_devices != 0:\\n (error, handle) = sensel.openDeviceByID(device_list.devices[0].idx)\\n return handle\",\n \"def close_app(self):\\n os.system ('adb shell am force-stop com.tencent.mm')\",\n \"def open(self, deviceID):\\r\\n \\r\\n return self._performAction(deviceID, _API_DEVICE_ACTION_OPEN)\",\n \"def do_start(self, str_arg):\\n try:\\n # self.adbc.startActivity(validateString(str_arg))\\n # the above approach failed in unittest complaining device is offline, weird...\\n return self.runAdbCmd('shell am start -n', validateString(str_arg))\\n except RuntimeError:\\n self.resultFlag = False\\n if DEBUG:\\n traceback.print_exc()\",\n \"def smartx_cmd(ctx):\\n webbrowser.open(\\\"https://smartx.ont.io/\\\")\",\n \"def startAndroidDeviceMonitor(self, event):\\n try:\\n os.startfile(r\\\"C:\\\\Users\\\\sam_JOYCE\\\\AppData\\\\Local\\\\Android\\\\Sdk\\\\tools\\\\lib\\\\monitor-x86_64\\\\monitor.exe\\\")\\n self.SetStatusText(f\\\"Successfully started Android Device Monitor\\\")\\n except FileNotFoundError:\\n self.SetStatusText(f\\\"Not Found. Please install the Android SDK\\\")\",\n \"def go_to_home_application(self):\\n self.parent.show()\\n self.hide()\",\n \"def open_audible_com(self):\\n self.driver.get(\\\"http://www.audible.com\\\")\\n\\n self._go_to_audible_com_if_on_uk_page()\",\n \"def launchMinipadServer(self):\\n return\",\n \"def open(alias):\\n s = db.Series.alias_lookup(alias)\\n click.launch(s.url)\",\n \"def open_device_dialog(self):\\n res, device = DeviceDialog.get_device(self.indexer)\\n if res and device:\\n self.serial = device.serial\\n if self.serial:\\n caps_str = None\\n self.open_device(self.serial, caps_str)\",\n \"def startapp(self, command):\\n e = self.emu\\n e.alt(\\\"F2\\\")\\n e.shortwait()\\n e.clickat(self.screen.center)\\n e.shortwait()\\n e.type(command + \\\"\\\\n\\\")\\n e.longwait()\",\n \"def open_link(self):\\n try:\\n # webbrowser.open(self.url) # if you are on Windows OS\\n webbrowser.get('safari').open_new_tab(self.url) # if you are on Mac OS\\n except(AttributeError):\\n self.ids.label.text = self.error_msg\",\n \"def home():\\n G.DEVICE.home()\",\n \"def platform_start(self):\\n self.platform.start()\",\n \"def install_app(device, path):\\n command = 'install \\\"%s\\\" \\\"%s\\\"' % (device.udid, path)\\n _run_command(command)\",\n \"def view_app(request, pk):\\n\\n app = get_object_or_404(MacOSApp, pk=pk)\\n\\n context = {'app': app}\\n return render(request, 'mdm/app_detail.html', context)\",\n \"def startapp():\",\n \"def open_in_web(self, model=None, model_id=None):\\n if model is not None:\\n model.open_in_web()\\n elif model_id is not None:\\n self._client_api._open_in_web(url=self.platform_url + '/' + str(model_id) + '/main')\\n else:\\n self._client_api._open_in_web(url=self.platform_url)\",\n \"def click_nav_desktops_mac(self):\\n self.click_nav_desktops()\\n self.driver.find_element(*BasePageLocators.MAC).click()\\n return ProductsPage(self.driver)\",\n \"def launch_app(item,terminal=False):\\n try:\\n if terminal:\\n subprocess.Popen(['/bin/terminal',item])\\n else:\\n subprocess.Popen(shlex.split(item))\\n except:\\n pass\",\n \"def launch (self):\\n path = \\\"\\\"\\n os.system(path + 'kidlogger_user.exe')\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def aboutThermAP():\\n import webbrowser\\n url = os.path.join(progpath, \\\"ThermAP_presentation.pdf\\\")\\n if platform.system() == \\\"Darwin\\\":\\n webbrowser._browsers['safari'][1].open(url)\\n else:\\n webbrowser.open(url)\",\n \"def open_link(self) -> None:\\n\\n webbrowser.open_new(self.link)\",\n \"def start_app(self, App):\\n self.app = App(device=self.device,\\n simulator=self.simulator)\\n self.app.exec_()\\n self.app = TimeWordsApp(device=self.device,\\n simulator=self.simulator)\",\n \"def try_continue_to_openManage_mobile():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n if g.platform == 'android':\\r\\n\\r\\n 'Getting y_elem as destination element'\\r\\n y_elem = ui_controls.ui_element(get_obj_identifier('common_widget_scrollview'))\\r\\n\\r\\n 'Getting x_elem as source element'\\r\\n x_elem = ui_controls.ui_element(get_obj_identifier('demo_tryDemoMode_btn'))\\r\\n\\r\\n 'Scroll the element from x elem to y elem'\\r\\n flag1 = ui_controls.scroll_element(x_elem, y_elem)\\r\\n sleep(3)\\r\\n\\r\\n 'Click on Continue to OMM button'\\r\\n flag2 = ui_controls.button(get_obj_identifier('demo_continueToOmm_btn'))\\r\\n\\r\\n status = False if not (flag1 and flag2) else True\\r\\n else:\\r\\n sleep(3)\\r\\n flag1=ui_controls.swipe_up()\\r\\n sleep(3)\\r\\n 'Click on Continue to OMM button in IOS'\\r\\n flag2 = ui_controls.button(get_obj_identifier('demo_continueToOmm_btn'))\\r\\n sleep(4)\\r\\n \\r\\n status = False if not (flag1 and flag2) else True\\r\\n\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def createApp(self):\\n app = self.app\\n window = self.window\\n window.show()\\n app.exec()\",\n \"def show(filepath):\\n if os.name == 'mac': subprocess.call(('open', filepath))\\n elif os.name == 'nt': os.startfile(filepath)\",\n \"def openSite(url):\\n\\timport webbrowser\\n\\twebbrowser.open('http://www.' + url + '.com', 2)\",\n \"def open_settings(self):\\n self.android_device_driver.adb.exec_adb_cmd(\\n \\\"shell am start -a android.settings.SETTINGS\\\").wait()\",\n \"def runApp(self, theEmulator, theApkObj):\\n # Clear log\\n self.log.info('Clear log')\\n theEmulator.clearLog()\\n \\n # Install app\\n self.log.info('- Installing app...')\\n \\n numRetries = 0\\n while True:\\n numRetries += 1\\n self.log.info('Try %d times to install app' % numRetries)\\n try:\\n theEmulator.installApp(theApkObj.get_filename())\\n break\\n except EmulatorClientError, ecErr:\\n errorOccuredFlag = True\\n if ecErr.getCode() == EmulatorClientError.INSTALLATION_ERROR_ALREADY_EXISTS:\\n break\\n if ecErr.getCode == EmulatorClientError.GENERAL_INSTALLATION_ERROR:\\n self.log.error('Can\\\\'t install app!')\\n \\n elif ecErr.getCode() == EmulatorClientError.INSTALLATION_ERROR_SYSTEM_NOT_RUNNING:\\n if numRetries == 4:\\n self.log.info('Number of maximum retries reached, abort installation')\\n else:\\n # Wait and retry\\n errorOccuredFlag = False\\n waitTime = numRetries * 10\\n self.log.info('Installation failed as system might not be running. Wait for %dsec and try again' % waitTime)\\n time.sleep(waitTime)\\n continue\\n if errorOccuredFlag: # Error occured\\n # Return\\n return False\\n \\n # Start logcat redirect\\n self.logcatRedirectFile = DynamicAnalyzerConst.LOGCAT_REDIRECT_FILE\\n theEmulator.startLogcatRedirect(self.logcatRedirectFile, 4096)\\n \\n # Switch on taint tracking\\n theEmulator.changeGlobalTaintLogState('1', True)\\n \\n # Run main activity\\n try:\\n mainActivity = theApkObj.get_main_activity()\\n if mainActivity:\\n self.log.info('Start main activity %s' % mainActivity)\\n theEmulator.startActivity(theApkObj.get_package(), mainActivity)\\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_ACTIVITY_TIME)\\n else:\\n self.log.info('No MainActivity found!')\\n except Exception,ecErr:\\n self.log.exce(traceback.format_exc())\\n \\n # Capture Screen\\n rawFile = os.path.join(self.decompressPath, 'raw.tmp')\\n destFile = os.path.join(self.decompressPath, 'screenshot')\\n ffmpeg = os.path.join(self.mainDir, DynamicAnalyzerConst.FFMPEG_PATH)\\n self._captureScreen(theEmulator, rawFile, destFile, ffmpeg)\\n \\n # Sleep for a little time to capture screen\\n time.sleep(2)\\n \\n self.log.info('Start all services...')\\n try:\\n for service in theApkObj.get_services():\\n self.log.info('Start service %s' % service)\\n theEmulator.startService(theApkObj.get_package(), service)\\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_SERVICE_TIME)\\n except EmulatorClientError, ecErr:\\n self.log.exce(traceback.format_exc())\\n \\n self.log.info('Start all receivers...')\\n try:\\n for receiver in theApkObj.get_receivers():\\n self.log.info('Start receiver %s' % receiver)\\n theEmulator.startReceiver(theApkObj.get_package(), receiver)\\n time.sleep(DynamicAnalyzerConst.THREAD_SLEEP_SERVICE_TIME)\\n except EmulatorClientError, ecErr:\\n self.log.exce(traceback.format_exc())\\n \\n return True\",\n \"def open_program(path):\\r\\n os.startfile(path)\",\n \"def run(self, url=''):\\n if url:\\n webbrowser.open(url)\",\n \"def open(self):\\n self._command = \\\"open\\\"\",\n \"def on_OpenExplorer_clicked(self):\\n # TODO: not implemented yet\\n #raise NotImplementedError\\n\\n url=\\\"http://kfc.matrix.io\\\"\\n\\n self.browser.openurl(url)\\n self.OnlyDisplay(f\\\"start {url}\\\")\\n #MATRIXWebutil.open_new(url)\\n #MATRIXWebutil.open_new_tab(url)\",\n \"def start(self):\\n\\n self.app.go()\",\n \"def do_device(self, args):\\n self.device_command.cmdloop(\\\"Enter to device mode\\\")\",\n \"def open_app_launcher(self, retry=True):\\n\\n self._jsclick(\\\"sf:app_launcher.button\\\")\\n self._jsclick(\\\"sf:app_launcher.view_all\\\")\\n self.wait_until_modal_is_open()\\n try:\\n # the modal may be open, but not yet fully rendered\\n # wait until at least one link appears. We've seen that sometimes\\n # the dialog hangs prior to any links showing up\\n self.selenium.wait_until_element_is_visible(\\n \\\"xpath://ul[contains(@class, 'al-modal-list')]//li\\\"\\n )\\n\\n except Exception as e:\\n # This should never happen, yet it does. Experience has\\n # shown that sometimes (at least in spring '20) the modal\\n # never renders. Refreshing the modal seems to fix it.\\n if retry:\\n self.builtin.log(\\n f\\\"caught exception {e} waiting for app launcher; retrying\\\", \\\"DEBUG\\\"\\n )\\n self.selenium.press_keys(\\\"sf:modal.is_open\\\", \\\"ESCAPE\\\")\\n self.wait_until_modal_is_closed()\\n self.open_app_launcher(retry=False)\\n else:\\n self.builtin.log(\\n f\\\"caught exception waiting for app launcher; not retrying\\\", \\\"DEBUG\\\"\\n )\\n raise\",\n \"def open(self, app, pane = None, **args):\\n\\t\\tpass\",\n \"def open_web_browser(whac_config: WhacConfig) -> None:\\n if whac_config.open_web_browser:\\n browser = webbrowser.get('chrome')\\n browser.open('http://localhost:' + str(whac_config.host_port), new=2, autoraise=True)\",\n \"def goHome():\\n\\t#Go to pod home\\n\\tif screen.lastScreen in screen.protectedScreens:\\n\\t\\tpodScreen.show()\\n\\telse:\\n\\t\\tsplashScreen.show()\",\n \"def connect_app(self, sid):\\r\\n return applications.ConnectApp(self, sid)\",\n \"def open_url(self):\\n self.window = QMainWindow()\\n self.ui_linkreader = Ui_LinkReader()\\n self.ui_linkreader.setup_ui(self.window)\\n self.ui_linkreader.pushButton.setDefault(True)\\n self.window.setFixedSize(self.window.width(), self.window.height())\\n self.ui_linkreader.pushButton.clicked.connect(self.process_url)\\n self.window.show()\",\n \"def install(filepath, **kwargs):\\n return G.DEVICE.install_app(filepath, **kwargs)\",\n \"def start():\\r\\n\\r\\n userName = userLogin.login()\\r\\n runApp(userName)\",\n \"def open(url):\\r\\n webbrowser.open(url)\",\n \"def cmd_start(self, app_name=None):\\n rc = self.socket_command_with_project('start', app_name)\\n return rc\",\n \"def play_btn_push(self):\\n try:\\n pl_name = self.pl_line_edit.text().replace(\\\" \\\", \\\"_\\\")\\n path = os.path.abspath(\\\"Playlists/\\\"+ pl_name+\\\".m3u\\\")\\n\\n #if sys.platform == \\\"linux\\\" or sys.platform == \\\"linux2\\\":\\n #print(\\\"linux\\\")\\n\\n if sys.platform == \\\"darwin\\\":\\n subprocess.call([\\\"open\\\", path])\\n\\n elif sys.platform == \\\"win32\\\":\\n os.startfile(path)\\n except:\\n QMessageBox.about(self, \\\"OS not recognized\\\",\\n 'Could not recognize operating system.')\",\n \"def open_in_browser(self):\\n webbrowser.open(self.url)\",\n \"def enable_mobile(self, android_package: str = None, android_activity: str = None, device_serial: str = None):\\n if not android_package:\\n raise AttributeError(\\\"android_package must be passed in\\\")\\n self.mobile_options = {\\n \\\"androidPackage\\\": android_package\\n }\\n if android_activity:\\n self.mobile_options[\\\"androidActivity\\\"] = android_activity\\n if device_serial:\\n self.mobile_options[\\\"androidDeviceSerial\\\"] = device_serial\",\n \"def openQrApp(self):\\n self.qrApp_Window = QtWidgets.QDialog()\\n self.openQrApp_ui = Ui_qrReaderApp()\\n self.openQrApp_ui.setupUi(self.qrApp_Window)\\n self.qrApp_Window.show()\",\n \"def open_target (tgt):\\n if sys.platform == \\\"darwin\\\":\\n #\\n # on OSX\\n #\\n open_exe = \\\"open\\\"\\n elif 'DISPLAY'in os.environ:\\n #\\n # on Linux/Un*x\\n #\\n open_exe = \\\"xdg-open\\\"\\n else:\\n #\\n # do nothing on other platforms\\n #\\n return\\n try:\\n pb = subprocess.Popen ([open_exe, tgt],\\n stdout=open(\\\"/dev/null\\\", \\\"w\\\"),\\n stderr=open(\\\"/dev/null\\\", \\\"w\\\"))\\n pb.wait ( )\\n except OSError:\\n logging.warning (\\\"Could not open [%s]\\\" % tgt)\\n else:\\n if pb.returncode != 0:\\n logging.warning (\\\"Could not open [%s]\\\" % tgt)\",\n \"def getWebDriverInstance(self):\\n #baseURL = \\\"https://qa-test.avenuecode.com/\\\"\\n if self.device == \\\"ios_mobile\\\":\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n #return driver\\n #driver.get(baseURL)\\n\\n else:\\n print(\\\"Hello\\\")\\n # Setting Driver Implicit Time out for An Element\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n return self.driver\\n # Maximize the window\\n #driver.maximize_window()\\n # Loading browser with App URL\\n #driver.get(baseURL)\\n #return driver\",\n \"def web():\\n env['remote_port'] = env['port_map']['8000']\\n\\n sys.stdout.write('Launching browser on remote port %(remote_port)s\\\\n' % env)\\n\\n run('open http://%(relay_server)s:%(remote_port)s' % env)\",\n \"def open_browser(url):\\n import webbrowser\\n webbrowser.open_new(url)\",\n \"def open(self) -> None:\\n if not self.__opened:\\n if self.path is None:\\n self.path = HID.enumerate_devices(self.vendor_id)[0]\\n self.device.open_path(self.path)\\n self.device.set_nonblocking(True)\\n self.__opened = True\",\n \"def check_mobile(request):\\n MOBILE_AGENT_RE=re.compile(r\\\".*(iphone|mobile|androidtouch)\\\",re.IGNORECASE)\\n\\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\\n return True\\n else:\\n return False\",\n \"def open(self):\\n if self._connected:\\n try:\\n self.native.find_prompt()\\n except: # noqa E722 pylint: disable=bare-except\\n self._connected = False\\n\\n if not self._connected:\\n self.native = ConnectHandler(\\n device_type=\\\"cisco_asa\\\",\\n ip=self.host,\\n username=self.username,\\n password=self.password,\\n port=self.port,\\n global_delay_factor=self.global_delay_factor,\\n secret=self.secret,\\n verbose=False,\\n )\\n self._connected = True\\n\\n log.debug(\\\"Host %s: Connection to controller was opened successfully.\\\", self.host)\",\n \"def open_database(app):\\n app.status.message(\\\"Opening DICOM folder..\\\")\\n path = app.dialog.directory(\\\"Select a DICOM folder\\\")\\n if path == '':\\n app.status.message('') \\n return\\n app.status.cursorToHourglass()\\n app.close()\\n app.open(path)\\n app.status.hide()\\n app.status.cursorToNormal()\",\n \"def open_top():\\n _open_url_path('')\",\n \"def launch_app(simulator_name, bundle_id):\\n logging.info(\\\"Launching app {BUNDLE_ID} on simulator '{SIMULATOR}'...\\\".format(BUNDLE_ID=bundle_id, SIMULATOR=simulator_name))\\n\\n try:\\n p = subprocess.Popen(\\n \\\"xcrun simctl launch '{SIMULATOR}' '{BUNDLE_ID}'\\\".format(SIMULATOR=simulator_name, BUNDLE_ID=bundle_id),\\n shell=True,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n universal_newlines=True\\n )\\n output = p.communicate()[0].rstrip()\\n\\n app_pid = int(str(output.strip()).split(\\\" \\\")[1])\\n logging.info(\\\"PID of launched application: [{PID}]\\\".format(PID=app_pid))\\n\\n except Exception as e:\\n logging.error(\\\"Launching the APP failed with error '{ERROR}'\\\".format(ERROR=e))\\n return None\\n\\n logging.info(\\\"Application launched successfuly!\\\")\\n return app_pid\",\n \"def onCaptureMobileLinkClicked(self, linkId=None):\\n self.LinkMobileMacro.emit()\",\n \"def open_url(self, url):\\n\\n self.driver.get(url)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77800596","0.7442968","0.7184208","0.62102145","0.6025373","0.6014739","0.591356","0.58947474","0.58312345","0.58172476","0.57678336","0.5743146","0.5674543","0.5626196","0.56029844","0.5575846","0.55363363","0.5530113","0.55267155","0.5506385","0.5504056","0.55030274","0.5489673","0.548677","0.54763585","0.54267466","0.5411011","0.5356932","0.5341705","0.53127","0.53111774","0.5249302","0.52166086","0.5210736","0.5203918","0.51948804","0.5175228","0.5162552","0.5134431","0.51243246","0.5098032","0.5095213","0.5082557","0.50575554","0.5029372","0.50269425","0.5021521","0.5020014","0.5011295","0.49947202","0.49806246","0.49775076","0.49565908","0.4943862","0.49410045","0.49325162","0.49051896","0.48905972","0.48905972","0.48776177","0.4864653","0.48420888","0.48359224","0.4834971","0.4826452","0.48156768","0.4809587","0.48014036","0.47946164","0.47934937","0.47927734","0.47914043","0.47778127","0.47773004","0.47692215","0.4766577","0.47622988","0.47595996","0.4757918","0.47404936","0.47402495","0.47287172","0.47245207","0.47093084","0.47088403","0.4704627","0.4698216","0.46976492","0.46945038","0.46943006","0.46928188","0.4678377","0.465978","0.46572167","0.4656475","0.46558005","0.46548107","0.46497217","0.4644412","0.4643469"],"string":"[\n \"0.77800596\",\n \"0.7442968\",\n \"0.7184208\",\n \"0.62102145\",\n \"0.6025373\",\n \"0.6014739\",\n \"0.591356\",\n \"0.58947474\",\n \"0.58312345\",\n \"0.58172476\",\n \"0.57678336\",\n \"0.5743146\",\n \"0.5674543\",\n \"0.5626196\",\n \"0.56029844\",\n \"0.5575846\",\n \"0.55363363\",\n \"0.5530113\",\n \"0.55267155\",\n \"0.5506385\",\n \"0.5504056\",\n \"0.55030274\",\n \"0.5489673\",\n \"0.548677\",\n \"0.54763585\",\n \"0.54267466\",\n \"0.5411011\",\n \"0.5356932\",\n \"0.5341705\",\n \"0.53127\",\n \"0.53111774\",\n \"0.5249302\",\n \"0.52166086\",\n \"0.5210736\",\n \"0.5203918\",\n \"0.51948804\",\n \"0.5175228\",\n \"0.5162552\",\n \"0.5134431\",\n \"0.51243246\",\n \"0.5098032\",\n \"0.5095213\",\n \"0.5082557\",\n \"0.50575554\",\n \"0.5029372\",\n \"0.50269425\",\n \"0.5021521\",\n \"0.5020014\",\n \"0.5011295\",\n \"0.49947202\",\n \"0.49806246\",\n \"0.49775076\",\n \"0.49565908\",\n \"0.4943862\",\n \"0.49410045\",\n \"0.49325162\",\n \"0.49051896\",\n \"0.48905972\",\n \"0.48905972\",\n \"0.48776177\",\n \"0.4864653\",\n \"0.48420888\",\n \"0.48359224\",\n \"0.4834971\",\n \"0.4826452\",\n \"0.48156768\",\n \"0.4809587\",\n \"0.48014036\",\n \"0.47946164\",\n \"0.47934937\",\n \"0.47927734\",\n \"0.47914043\",\n \"0.47778127\",\n \"0.47773004\",\n \"0.47692215\",\n \"0.4766577\",\n \"0.47622988\",\n \"0.47595996\",\n \"0.4757918\",\n \"0.47404936\",\n \"0.47402495\",\n \"0.47287172\",\n \"0.47245207\",\n \"0.47093084\",\n \"0.47088403\",\n \"0.4704627\",\n \"0.4698216\",\n \"0.46976492\",\n \"0.46945038\",\n \"0.46943006\",\n \"0.46928188\",\n \"0.4678377\",\n \"0.465978\",\n \"0.46572167\",\n \"0.4656475\",\n \"0.46558005\",\n \"0.46548107\",\n \"0.46497217\",\n \"0.4644412\",\n \"0.4643469\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68002564"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":23496,"cells":{"query":{"kind":"string","value":"Count letters in a name."},"document":{"kind":"string","value":"def counter(name):\n count_name = list(name)\n counter = 0\n for letter in count_name:\n counter += 1\n\n print(f\"There are {counter} letter in the name {name}.\")\n print(f\"\\tAnd btw... {name} backwards is {name[::-1].lower()}.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def char_count(self, _list, char):\n\t\tcont = 0\n\t\tfor i in _list:\n\t\t\tcont += i[\"name\"].count(char.upper())\n\t\t\tcont += i[\"name\"].count(char.lower())\n\t\treturn cont","def test_single_letter_count(self):\n self.assertEqual(functions.single_letter_count(\"Hello World\", \"h\"), 1)\n self.assertEqual(functions.single_letter_count(\"Hello World\", \"z\"), 0)\n self.assertEqual(functions.single_letter_count(\"HelLo World\", \"l\"), 3)","def count_letters(wordform: str):\n return len(re.findall('[a-z]', wordform))","def count_letters(word, letter):\n assert isinstance(word, str) == True, \"Please input a string!\"\n count = 0\n for char in word:\n if char == letter:\n count += 1\n\n return count","def letter_count( text ):\n\tchars = string.ascii_uppercase\n\ttext = text.upper()\n\tresult = get_letter_dict()\n\tfor char in chars:\n\t\tresult[char] = text.count(char)\n\treturn result","def count_letter(content, letter):\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])","def count_letter(content, letter):\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])","def count_letter(content, letter):\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])","def count_letter(content, letter):\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])","def count_letter(content, letter):\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])","def count_alpha(word):\n\n alpha = re.compile(r'[a-z]', re.IGNORECASE)\n return len(alpha.findall(word))","def tester(name):\n return len(name)","def letterSpace(text):\n\n count = 0\n alphabet = string.ascii_lowercase + string.ascii_uppercase\n for char in text:\n if char in alphabet:\n count += 1\n return count","def count_name(text, adj):\n for x in re.finditer(r'[A-Z][a-z]*[\\s][A-Z][a-z]*',text):\n adj[x.group()] += 1\n return","def getNameNum(name):\n dicto = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}\n summ = 0\n for letter in name:\n summ += dicto.get(letter.lower())\n return summ","def test_multiple_letter_count(self):\n self.assertEqual(functions.multiple_letter_count(\"awesome\"), {\n 'a': 1, 'e': 2, 'm': 1, 'o': 1, 's': 1, 'w': 1})","def add_letter_count(self):\n self.dataframe['letter_count'] = self.dataframe['letter'].str.len()","def count_characters(text):\n counted_characters = initialize_dictionary_with_characters()\n for char in next_uppercase_character(text.upper()):\n counted_characters[char] += 1\n return counted_characters","def num_chars(word):\n return len(word)","def get_number_of_letters(self):\n filename = f'{self.path}/{self.filename}'\n file = open(filename, 'r', encoding='utf-8')\n \"\"\"Count number of lettes without digits, non letter characters, without xml tags\"\"\"\n data = file.read()\n data = re.sub('<.*?binary.*?>*<.*?binary.*?>',' ', data)\n data = re.sub('\\\\s\\\\s*', '', (re.sub('\\\\W|\\\\d', ' ', re.sub('<.*?>', '', data))))\n let_count = len(data)\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_letters', let_count)\n print(datetime.now(), '-', 'number_of_letters for', self.filename, 'calculated =', let_count)\n return None","def CountNames():\r\n return _hiew.HiewGate_Names_CountName()","def countLetters(inputtedString):\n\n counted = 0\n inBetween = list(inputtedString)\n i = 0\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n\n while i < len(inBetween):\n if inBetween[i] in alphabet:\n counted += 1\n i += 1\n\n return counted","def count(word):\n\n return len(word)","def fancy_count(sentence, alphabet):\n sentence = sentence.lower()\n\n # create dictionary of all letters set to 0\n letter_count = {}\n for char in alphabet:\n letter_count[char] = 0\n\n for char in sentence:\n if char in letter_count.keys():\n letter_count[char] += 1\n return letter_count","def value(name):\r\n return sum(alpha.index(str(l)) + 1 for l in name)","def count_letters_mod(word, letter, index=0):\n count = 0\n while index < len(word):\n result = word.find(letter, index)\n if result != -1:\n count += 1\n index = result + 1\n else:\n index += 1\n\n return count","def basic_count(sentence):\n letter_count = {}\n for char in sentence:\n if char not in letter_count:\n letter_count[char] = 0\n letter_count[char] += 1\n return letter_count","def word_char_count(word):\n\talphabet = alphabet_init()\n\tfor i in range(len(word)):\n\t\tchar_index = convert_letter_to_int(word[i])\n\t\talphabet[char_index] += 1 \n\treturn alphabet","def frequencyLetterDic(s):\n pass","def count(self, word):\n pass","def letters(self, path, filemoving, parser):\n root = parser.parsing_xml(path, filemoving)\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\n number_of_letters = 0\n for i in root.iter(root_tag+'p'):\n if str(type(i.text)) == \"<class 'str'>\":\n number_of_letters = number_of_letters + len([letter for letter in i.text if letter.isalnum()])\n return number_of_letters","def alpha_score(upper_letters):\r\n return sum(map(lambda l: 1 + ord(l) - ord('A'), upper_letters))","def alpha_score(upper_letters):\r\n return sum(map(lambda l: 1 + ord(l) - ord('A'), upper_letters))","def string_substring_count(\n word,\n letter,\n):\n count = 0\n index = 0\n while index < len(word):\n result = word.find(letter, index)\n if result != -1:\n count += 1\n index = result + 1\n else:\n index += 1\n\n return count","def count_chars(text):\n alphabet_counts = [0] * len(alphabet)\n\n for char in text:\n index = char_index.get(char, -1)\n\n if index >= 0:\n alphabet_counts[index] += 1\n\n return alphabet_counts","def count(self, character):\n c_list = [i for i in self.input_words]\n n = sum([True for char in c_list if char == character])\n return n","def getLength(message):\r\n length = 0\r\n for char in message:\r\n if char in alphaUpper or alphaLower:\r\n length += 1\r\n return length","def letter_name(lst, letter):\n arr = [0 for i in range(100)]\n counter = 0\n for name in lst:\n letter = name[0][0].lower()\n order = ord(letter) - 1072\n arr[order] += 1\n maximum = 0\n letter = \"\"\n for i in range(len(arr)):\n if arr[i] > maximum:\n maximum = arr[i]\n letter = chr(i + 1072)\n arr_of_names = []\n sum_of_children = 0\n for name in lst:\n if name[0][0].lower() == letter:\n arr_of_names.append(name[0])\n sum_of_children += name[1]\n return letter, maximum, arr_of_names, sum_of_children","def which_letters(sentence, wanted_letters):\n sentence = sentence.lower()\n\n # create dictionary of all letters set to 0\n letter_count = {}\n for char in wanted_letters:\n letter_count[char] = 0\n\n for char in sentence:\n if char in letter_count.keys():\n letter_count[char] += 1\n return letter_count","def count_abbas(str):\r\n i = 0\r\n count = 0\r\n for i in range(0, len(str)):\r\n if str.startswith(\"abba\", i):\r\n count += 1\r\n return count","def test_char_count_for_correct_output(self):\n self.assertDictEqual(char_count(\"an apple a day will keep the doctor away\"), {'a': 6, 'e': 4, 'p': 3, 'l': 3, 'd': 2, 'y': 2, 'w': 2, 't': 2, 'o': 2, 'n': 1, 'i': 1, 'k': 1, 'h': 1, 'c': 1, 'r': 1})","def vowelcount (x):\n x.lower ()\n print (x.count('a')+x.count('e')+x.count('i')+x.count('o')+x.count('u'))","def length_of_name(self, name):\n length = len(name)\n if length > 10:\n self.show_message_when_name_very_long()\n return length","def get_letter_counts(str_):\n return dict(Counter(str_))","def length(string):\n number=0#the length of the string starts from 0\n for num in string:#go over all the letter in the string\n number=number+1\n print('the length is',number)","def test_ababab():\n assert part_01.count_for('ababab', 2) == 0\n assert part_01.count_for('ababab', 3) == 1","def getAlphaNumCharCount(sdata):\n\tacount = 0\n\tncount = 0\n\tscount = 0\n\tocount = 0\n\tassertEqual(type(sdata), str, \"input must be string\")\n\tfor c in sdata:\n\t\tif c.isnumeric():\n\t\t\tncount += 1\n\t\telif c.isalpha():\n\t\t\tacount += 1\n\t\telif c.isspace():\n\t\t\tscount += 1\n\t\telse:\n\t\t\tocount += 1\n\tr = (acount, ncount, ocount)\n\treturn r","def count_letters(word_list):\n \n ALPHABET = \"abcdefghijklmnopqrstuvwxyz\"\n\n letter_count = {}\n for item in word_list:\n for letter in item:\n if letter in letter_count:\n letter_count[letter] += 1\n else:\n letter_count[letter] = 1\n return letter_count","def count_dashes(txt):\n count = 0\n for c in txt:\n if c == '-':\n count += 1\n return count","def vowelcount(x):\n vowel = ['a', 'e', 'i', 'o', 'u']\n counter = 0\n\n for i in range(len(vowel)):\n a = x.count(vowel[i].lower())\n counter = counter + a\n a = x.count(vowel[i].upper())\n counter = counter + a\n\n return counter","def getWordCharCount(w):\r\n rus = len(re.findall(r\"[а-я]\",w))\r\n eng = len(re.findall(r\"[a-z]\",w))\r\n c = len(w) \r\n return c, rus, eng","def letter_freq( text ):\n\tchars = string.ascii_uppercase\n\ttext = text.upper()\n\tresult = get_letter_dict()\n\ttotal = 0\n\tfor char in chars:\n\t\tcount = text.count(char)\n\t\tresult[char] = count\n\t\ttotal += count\n\tif total != 0:\n\t\tfor char in chars:\n\t\t\tresult[char] = (result[char]*10000 / total) / float(100)\n\treturn result","def problem(args:int) -> int:\r\n\ts = 0\r\n\tfor i in range(1, args + 1):\r\n\t\ts += letter_count(i)\r\n\treturn s","def countCharacters(file_name, start, end):\r\n\r\n with open(file_name, \"r\") as file:\r\n counter_chars = 0\r\n\r\n for line in islice(file, start, end):\r\n counter_chars += len(line)\r\n\r\n return counter_chars","def vowelcount(s):\n s = s.lower()\n nv = 0\n for v in 'aeiou':\n nv += s.count(v)\n return nv","def letter_percent(s):\r\n\r\n alpha = 'abcdefghijklmnopqrstuvwxyz'\r\n s_lower = s.lower()\r\n s_length = 0\r\n letter_count = {} # empty dictionary\r\n keys = letter_count.keys()\r\n\r\n for char in s_lower:\r\n if char in alpha:\r\n s_length = s_length + 1\r\n if char in letter_count:\r\n letter_count[char] = letter_count[char] + 1\r\n else:\r\n letter_count[char] = 1\r\n\r\n for char in sorted(keys):\r\n letter_count[char] = (letter_count[char] / s_length) * 100\r\n print(char, \"{:.1f}%\".format(letter_count[char]))","def calculateValue(name):\n\tscore = 0\n\tfor c in name:\n\t\tscore += ord(c) - ord('A') + 1\n\treturn score","def add_word_count(self):\n self.dataframe['word_count'] = self.dataframe.letter.str.count('\\w+')","def count(text):\n return len(text)","def duplicate_count(text: str) -> int:\n\n max_count = 0\n char_exclude = []\n for char in text:\n if char.isalpha():\n text = text.replace(char, char.lower())\n char = char.lower()\n if char not in char_exclude and text.count(char) > 1:\n char_exclude.append(char)\n max_count += 1\n return max_count","def theLoveLetterMystery(s):\n mincount = 0\n for i in range(len(s) // 2):\n mincount += abs(ord(s[i]) - ord(s[-1 - i]))\n\n return mincount","def count(self, char):\n return self._sequence.count(char)","def letternum(letter):\n if not isinstance(letter, str):\n raise TypeError(\"Invalid letter provided.\")\n if not len(letter) == 1:\n raise ValueError(\"Invalid letter length provided.\")\n letter = letter.lower()\n alphaletters = string.ascii_lowercase\n for i in range(len(alphaletters)):\n if letter[0] == alphaletters[i]:\n return i + 1","def count_exclamations(txt):\n count = 0\n for c in txt:\n if c == '!':\n count += 1\n return count","def repeatedString(s, n):\n\n count = 0\n s_count_a = s.count('a')\n\n count += math.floor(n / len(s)) * s_count_a\n for _ in range(n % len(s)):\n if s[_] == 'a':\n count += 1\n\n return count","def countAll(word):\n counts = {}\n for char in word.lower():\n if char not in counts:\n counts[char] = 1\n else:\n counts[char] += 1\n return counts","def main():\n\n numBob = 0\n i = 0\n\n for letters in s:\n if i < (len(s)-2):\n if letters == 'b':\n if s[i+1] == 'o':\n if s[i+2] == 'b':\n numBob += 1\n i = i +1\n\n\n print('Number of times bob occurs is: ' + str(numBob))","def count(self):\n return len(self.names)","def countCharacters(self, words, chars):\n chars_dict = self.count_to_dict(chars)\n chars_set = chars_dict.keys()\n len_chars_set = len(chars_set)\n \n good_string = ''\n for words_i in words:\n word_dict = self.count_to_dict(words_i)\n words_i_set = word_dict.keys()\n check = 0\n for i in words_i_set:\n if i not in chars_set:\n check+=1\n break\n if word_dict[i] > chars_dict[i]:\n check+=1\n break\n if check == 1:\n continue\n good_string = good_string+words_i\n return len(good_string)","def test_aabcdd():\n assert part_01.count_for('abbcdd', 2) == 1\n assert part_01.count_for('aabcdd', 3) == 0","def numLetterCount(maxNum):\n sum = 0\n for num in range(1,maxNum+1):\n sum += len(num2words(num))\n print(str(num) + ' = ' + str(num2words(num)))\n return sum","def num_mismatched_letters(self, word1:str, word2:str)-> int:\n assert(len(word1) == len(word2))\n count = 0\n # -----------------------------------------\n # TODO: You need to write this method.\n\n\n # -----------------------------------------\n return count","def letter_freq(txt):\n frequencies = {}\n txt_lower = txt.lower()\n\n for i in txt_lower:\n keys = frequencies.keys()\n if i in keys:\n frequencies[i] += 1\n else:\n frequencies[i] = 1\n return frequencies","def length(s: str) -> int:\n count = 0\n for i in s:\n count += 1\n return count","def test_number_in_word():\n assert syllapy.count(\"d0g\") == 0","def countWord(afz, word, output=True):\n count = 0\n for msg in msgs:\n if msg.afz == afz:\n count = count + msg.msg.lower().count(word.lower())\n print afz, 'heeft', count, 'keer', word, 'gezegd.'","def tally_letters(string):\n output = dict()\n for char in list(string):\n freq = output.get(char, 0)\n output[char]= freq+1\n return output","def namelength(self):\n return self[\"namelength\"]","def test_abbcde():\n assert part_01.count_for('abbcde', 2) == 1\n assert part_01.count_for('abbcde', 3) == 0","def letterCount(dict):\n # Making a new dictionary to store each letter's information in\n letters = dict.fromkeys(string.ascii_lowercase, 0)\n total = 0\n\n # Populating the letters-totals dictionary\n for key in dict:\n for letter in key:\n letters[letter] += dict[key].getNumber()\n # Total to keep track of all letters\n total += dict[key].getNumber()\n\n # Changing the letter-total data to letter-frequency data\n for entry in letters:\n letters[entry] = letters[entry] / total\n\n return letters","def duplicate_count(text):\n n = 0\n for c in set(text.lower()):\n if text.lower().count(c) > 1:\n n += 1\n return n","def letter_name(index):\n letters = string.ascii_lowercase\n count = len(letters)\n\n return letters[index % count] * ((index // count) + 1)","def gapRunCount(letters):\n uniqLetters = map(operator.itemgetter(0), groupby(letters))\n return uniqLetters.count(\"-\")","def most_repeating_letter_count(word):\n return Counter(word.lower()).most_common(1)[0][1]","def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\n return Counter(_naked_names_iter(graph))","def letter_text_analyzer(text, letter):\n count = 0\n text_mod = \"\"\n for char in text:\n if char not in string.punctuation:\n text_mod += char\n text_split = text_mod.split()\n\n for word in text_split:\n if letter in word:\n count += 1\n result = \"Your text contains {0} words,of which {1} ({2:.1%}) contain an '{3}'\"\n\n return result.format(len(text_split), count, count / len(text_split), letter)","def check_unique_name(first_letters, count, name, unique_list, suffix=False):\n if suffix:\n while name in unique_list:\n count += 1\n end_count = \"%03d\" % count\n name = name[:-3] + end_count\n else:\n while name in unique_list:\n count += 1\n end_count = \"%06d\" % count\n name = first_letters + \"_\" + end_count\n\n return name, count","def nwords(s: str):\n letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\"\n take = 0\n skip = 0\n for i in s:\n if i not in letters:\n skip += 1\n #print(\"S:\", skip)\n else:\n take += 1\n #print(\"t:\", take)\n res = (len(s) - take) + 1\n return res","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-s\", help=\"String to be used as list of letters (to be counted)\")\n args = parser.parse_args()\n counts = counter(list(args.s))\n print counts","def words_capital_letter(self, path, filemoving, parser):\n root = parser.parsing_xml(path, filemoving)\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\n number_of_words_capital_letter = 0\n for i in root.iter(root_tag+'p'):\n if str(type(i.text)) == \"<class 'str'>\":\n number_of_words_capital_letter = number_of_words_capital_letter + sum(list(map(lambda x: x.istitle(), i.text.split())))\n return number_of_words_capital_letter","def num_char(lista):\n all_c = \"\"\n for i in lista:\n all_c += str(i)\n return len(all_c)","def vowelcount(string):\n string = string.upper()\n i = string.count('A')\n i = i + string.count('E')\n i = i + string.count('I')\n i = i + string.count('O')\n i = i + string.count('U')\n i = i + string.count('Ä')\n i = i + string.count('Ö')\n i = i + string.count('Ü')\n print(string, \"contains \", i, \" vowels\")","def test_char_count_returns_a_dict(self):\n self.assertIsInstance(char_count(\"aaabbc\"), dict)","def count_upper_case(message):\n return sum([1 for c in message if c.isupper()])","def calc_word_score(word, letters_count, letters_score):\n\n output = 0\n # keep track of the used letters\n letters_remaining = dict(letters_count)\n\n for w in word:\n if w not in letters_count:\n # contains a letter outside the provided scope\n return 0\n if letters_remaining[w] == 0:\n # too many occurrences of that letter\n return 0\n output += letters_score[w]\n letters_remaining[w] -= 1\n\n return output","def letterFreq(words):\n dict = {}\n total = 0\n for word in words:#Iterate through words\n for letter in word:#Increment by letter\n count = 0\n for yearCount in words[word]:\n count += yearCount.count#Increment total instances of word\n total += count#Count total letters\n if letter in dict:\n dict[letter] += count#Add to existing entry\n else:\n dict[letter] = count#Create new entry\n \"\"\"CODE FOR THE WHOLE ALPHABET\"\"\"\n list = []\n for letter in ascii_lowercase:\n if letter in dict and dict[letter] != 0:\n list.append(dict[letter] / total)#Convert to relative\n else:\n list.append(0.0)#Fill alphabet\n return list","def heading_count(self, phrase,char='~'):\r\n count = 0\r\n for x in phrase:\r\n if x != char:\r\n break\r\n count+=1\r\n return count,phrase[count:]","def atomic_number(name):\n try:\n return symbols.index(name.capitalize()) + 1\n except ValueError:\n return lower_names.index(name.lower()) + 1","def _nth_letter(n):\r\n\treturn string.ascii_lowercase[n % len(string.ascii_lowercase)]","def duplicate_count(val):\n new_ls = []\n ls = []\n for char in val.lower():\n if char not in new_ls:\n new_ls.append(char)\n else:\n ls.append(char)\n return len(set(ls))"],"string":"[\n \"def char_count(self, _list, char):\\n\\t\\tcont = 0\\n\\t\\tfor i in _list:\\n\\t\\t\\tcont += i[\\\"name\\\"].count(char.upper())\\n\\t\\t\\tcont += i[\\\"name\\\"].count(char.lower())\\n\\t\\treturn cont\",\n \"def test_single_letter_count(self):\\n self.assertEqual(functions.single_letter_count(\\\"Hello World\\\", \\\"h\\\"), 1)\\n self.assertEqual(functions.single_letter_count(\\\"Hello World\\\", \\\"z\\\"), 0)\\n self.assertEqual(functions.single_letter_count(\\\"HelLo World\\\", \\\"l\\\"), 3)\",\n \"def count_letters(wordform: str):\\n return len(re.findall('[a-z]', wordform))\",\n \"def count_letters(word, letter):\\n assert isinstance(word, str) == True, \\\"Please input a string!\\\"\\n count = 0\\n for char in word:\\n if char == letter:\\n count += 1\\n\\n return count\",\n \"def letter_count( text ):\\n\\tchars = string.ascii_uppercase\\n\\ttext = text.upper()\\n\\tresult = get_letter_dict()\\n\\tfor char in chars:\\n\\t\\tresult[char] = text.count(char)\\n\\treturn result\",\n \"def count_letter(content, letter):\\n if (not isinstance(letter, str)) or len(letter) != 1:\\n raise ValueError('`letter` must be a single character string.')\\n return len([char for char in content if char == letter])\",\n \"def count_letter(content, letter):\\n if (not isinstance(letter, str)) or len(letter) != 1:\\n raise ValueError('`letter` must be a single character string.')\\n return len([char for char in content if char == letter])\",\n \"def count_letter(content, letter):\\n if (not isinstance(letter, str)) or len(letter) != 1:\\n raise ValueError('`letter` must be a single character string.')\\n return len([char for char in content if char == letter])\",\n \"def count_letter(content, letter):\\n if (not isinstance(letter, str)) or len(letter) != 1:\\n raise ValueError('`letter` must be a single character string.')\\n return len([char for char in content if char == letter])\",\n \"def count_letter(content, letter):\\n if (not isinstance(letter, str)) or len(letter) != 1:\\n raise ValueError('`letter` must be a single character string.')\\n return len([char for char in content if char == letter])\",\n \"def count_alpha(word):\\n\\n alpha = re.compile(r'[a-z]', re.IGNORECASE)\\n return len(alpha.findall(word))\",\n \"def tester(name):\\n return len(name)\",\n \"def letterSpace(text):\\n\\n count = 0\\n alphabet = string.ascii_lowercase + string.ascii_uppercase\\n for char in text:\\n if char in alphabet:\\n count += 1\\n return count\",\n \"def count_name(text, adj):\\n for x in re.finditer(r'[A-Z][a-z]*[\\\\s][A-Z][a-z]*',text):\\n adj[x.group()] += 1\\n return\",\n \"def getNameNum(name):\\n dicto = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}\\n summ = 0\\n for letter in name:\\n summ += dicto.get(letter.lower())\\n return summ\",\n \"def test_multiple_letter_count(self):\\n self.assertEqual(functions.multiple_letter_count(\\\"awesome\\\"), {\\n 'a': 1, 'e': 2, 'm': 1, 'o': 1, 's': 1, 'w': 1})\",\n \"def add_letter_count(self):\\n self.dataframe['letter_count'] = self.dataframe['letter'].str.len()\",\n \"def count_characters(text):\\n counted_characters = initialize_dictionary_with_characters()\\n for char in next_uppercase_character(text.upper()):\\n counted_characters[char] += 1\\n return counted_characters\",\n \"def num_chars(word):\\n return len(word)\",\n \"def get_number_of_letters(self):\\n filename = f'{self.path}/{self.filename}'\\n file = open(filename, 'r', encoding='utf-8')\\n \\\"\\\"\\\"Count number of lettes without digits, non letter characters, without xml tags\\\"\\\"\\\"\\n data = file.read()\\n data = re.sub('<.*?binary.*?>*<.*?binary.*?>',' ', data)\\n data = re.sub('\\\\\\\\s\\\\\\\\s*', '', (re.sub('\\\\\\\\W|\\\\\\\\d', ' ', re.sub('<.*?>', '', data))))\\n let_count = len(data)\\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_letters', let_count)\\n print(datetime.now(), '-', 'number_of_letters for', self.filename, 'calculated =', let_count)\\n return None\",\n \"def CountNames():\\r\\n return _hiew.HiewGate_Names_CountName()\",\n \"def countLetters(inputtedString):\\n\\n counted = 0\\n inBetween = list(inputtedString)\\n i = 0\\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\\n\\n while i < len(inBetween):\\n if inBetween[i] in alphabet:\\n counted += 1\\n i += 1\\n\\n return counted\",\n \"def count(word):\\n\\n return len(word)\",\n \"def fancy_count(sentence, alphabet):\\n sentence = sentence.lower()\\n\\n # create dictionary of all letters set to 0\\n letter_count = {}\\n for char in alphabet:\\n letter_count[char] = 0\\n\\n for char in sentence:\\n if char in letter_count.keys():\\n letter_count[char] += 1\\n return letter_count\",\n \"def value(name):\\r\\n return sum(alpha.index(str(l)) + 1 for l in name)\",\n \"def count_letters_mod(word, letter, index=0):\\n count = 0\\n while index < len(word):\\n result = word.find(letter, index)\\n if result != -1:\\n count += 1\\n index = result + 1\\n else:\\n index += 1\\n\\n return count\",\n \"def basic_count(sentence):\\n letter_count = {}\\n for char in sentence:\\n if char not in letter_count:\\n letter_count[char] = 0\\n letter_count[char] += 1\\n return letter_count\",\n \"def word_char_count(word):\\n\\talphabet = alphabet_init()\\n\\tfor i in range(len(word)):\\n\\t\\tchar_index = convert_letter_to_int(word[i])\\n\\t\\talphabet[char_index] += 1 \\n\\treturn alphabet\",\n \"def frequencyLetterDic(s):\\n pass\",\n \"def count(self, word):\\n pass\",\n \"def letters(self, path, filemoving, parser):\\n root = parser.parsing_xml(path, filemoving)\\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\\n number_of_letters = 0\\n for i in root.iter(root_tag+'p'):\\n if str(type(i.text)) == \\\"<class 'str'>\\\":\\n number_of_letters = number_of_letters + len([letter for letter in i.text if letter.isalnum()])\\n return number_of_letters\",\n \"def alpha_score(upper_letters):\\r\\n return sum(map(lambda l: 1 + ord(l) - ord('A'), upper_letters))\",\n \"def alpha_score(upper_letters):\\r\\n return sum(map(lambda l: 1 + ord(l) - ord('A'), upper_letters))\",\n \"def string_substring_count(\\n word,\\n letter,\\n):\\n count = 0\\n index = 0\\n while index < len(word):\\n result = word.find(letter, index)\\n if result != -1:\\n count += 1\\n index = result + 1\\n else:\\n index += 1\\n\\n return count\",\n \"def count_chars(text):\\n alphabet_counts = [0] * len(alphabet)\\n\\n for char in text:\\n index = char_index.get(char, -1)\\n\\n if index >= 0:\\n alphabet_counts[index] += 1\\n\\n return alphabet_counts\",\n \"def count(self, character):\\n c_list = [i for i in self.input_words]\\n n = sum([True for char in c_list if char == character])\\n return n\",\n \"def getLength(message):\\r\\n length = 0\\r\\n for char in message:\\r\\n if char in alphaUpper or alphaLower:\\r\\n length += 1\\r\\n return length\",\n \"def letter_name(lst, letter):\\n arr = [0 for i in range(100)]\\n counter = 0\\n for name in lst:\\n letter = name[0][0].lower()\\n order = ord(letter) - 1072\\n arr[order] += 1\\n maximum = 0\\n letter = \\\"\\\"\\n for i in range(len(arr)):\\n if arr[i] > maximum:\\n maximum = arr[i]\\n letter = chr(i + 1072)\\n arr_of_names = []\\n sum_of_children = 0\\n for name in lst:\\n if name[0][0].lower() == letter:\\n arr_of_names.append(name[0])\\n sum_of_children += name[1]\\n return letter, maximum, arr_of_names, sum_of_children\",\n \"def which_letters(sentence, wanted_letters):\\n sentence = sentence.lower()\\n\\n # create dictionary of all letters set to 0\\n letter_count = {}\\n for char in wanted_letters:\\n letter_count[char] = 0\\n\\n for char in sentence:\\n if char in letter_count.keys():\\n letter_count[char] += 1\\n return letter_count\",\n \"def count_abbas(str):\\r\\n i = 0\\r\\n count = 0\\r\\n for i in range(0, len(str)):\\r\\n if str.startswith(\\\"abba\\\", i):\\r\\n count += 1\\r\\n return count\",\n \"def test_char_count_for_correct_output(self):\\n self.assertDictEqual(char_count(\\\"an apple a day will keep the doctor away\\\"), {'a': 6, 'e': 4, 'p': 3, 'l': 3, 'd': 2, 'y': 2, 'w': 2, 't': 2, 'o': 2, 'n': 1, 'i': 1, 'k': 1, 'h': 1, 'c': 1, 'r': 1})\",\n \"def vowelcount (x):\\n x.lower ()\\n print (x.count('a')+x.count('e')+x.count('i')+x.count('o')+x.count('u'))\",\n \"def length_of_name(self, name):\\n length = len(name)\\n if length > 10:\\n self.show_message_when_name_very_long()\\n return length\",\n \"def get_letter_counts(str_):\\n return dict(Counter(str_))\",\n \"def length(string):\\n number=0#the length of the string starts from 0\\n for num in string:#go over all the letter in the string\\n number=number+1\\n print('the length is',number)\",\n \"def test_ababab():\\n assert part_01.count_for('ababab', 2) == 0\\n assert part_01.count_for('ababab', 3) == 1\",\n \"def getAlphaNumCharCount(sdata):\\n\\tacount = 0\\n\\tncount = 0\\n\\tscount = 0\\n\\tocount = 0\\n\\tassertEqual(type(sdata), str, \\\"input must be string\\\")\\n\\tfor c in sdata:\\n\\t\\tif c.isnumeric():\\n\\t\\t\\tncount += 1\\n\\t\\telif c.isalpha():\\n\\t\\t\\tacount += 1\\n\\t\\telif c.isspace():\\n\\t\\t\\tscount += 1\\n\\t\\telse:\\n\\t\\t\\tocount += 1\\n\\tr = (acount, ncount, ocount)\\n\\treturn r\",\n \"def count_letters(word_list):\\n \\n ALPHABET = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n\\n letter_count = {}\\n for item in word_list:\\n for letter in item:\\n if letter in letter_count:\\n letter_count[letter] += 1\\n else:\\n letter_count[letter] = 1\\n return letter_count\",\n \"def count_dashes(txt):\\n count = 0\\n for c in txt:\\n if c == '-':\\n count += 1\\n return count\",\n \"def vowelcount(x):\\n vowel = ['a', 'e', 'i', 'o', 'u']\\n counter = 0\\n\\n for i in range(len(vowel)):\\n a = x.count(vowel[i].lower())\\n counter = counter + a\\n a = x.count(vowel[i].upper())\\n counter = counter + a\\n\\n return counter\",\n \"def getWordCharCount(w):\\r\\n rus = len(re.findall(r\\\"[а-я]\\\",w))\\r\\n eng = len(re.findall(r\\\"[a-z]\\\",w))\\r\\n c = len(w) \\r\\n return c, rus, eng\",\n \"def letter_freq( text ):\\n\\tchars = string.ascii_uppercase\\n\\ttext = text.upper()\\n\\tresult = get_letter_dict()\\n\\ttotal = 0\\n\\tfor char in chars:\\n\\t\\tcount = text.count(char)\\n\\t\\tresult[char] = count\\n\\t\\ttotal += count\\n\\tif total != 0:\\n\\t\\tfor char in chars:\\n\\t\\t\\tresult[char] = (result[char]*10000 / total) / float(100)\\n\\treturn result\",\n \"def problem(args:int) -> int:\\r\\n\\ts = 0\\r\\n\\tfor i in range(1, args + 1):\\r\\n\\t\\ts += letter_count(i)\\r\\n\\treturn s\",\n \"def countCharacters(file_name, start, end):\\r\\n\\r\\n with open(file_name, \\\"r\\\") as file:\\r\\n counter_chars = 0\\r\\n\\r\\n for line in islice(file, start, end):\\r\\n counter_chars += len(line)\\r\\n\\r\\n return counter_chars\",\n \"def vowelcount(s):\\n s = s.lower()\\n nv = 0\\n for v in 'aeiou':\\n nv += s.count(v)\\n return nv\",\n \"def letter_percent(s):\\r\\n\\r\\n alpha = 'abcdefghijklmnopqrstuvwxyz'\\r\\n s_lower = s.lower()\\r\\n s_length = 0\\r\\n letter_count = {} # empty dictionary\\r\\n keys = letter_count.keys()\\r\\n\\r\\n for char in s_lower:\\r\\n if char in alpha:\\r\\n s_length = s_length + 1\\r\\n if char in letter_count:\\r\\n letter_count[char] = letter_count[char] + 1\\r\\n else:\\r\\n letter_count[char] = 1\\r\\n\\r\\n for char in sorted(keys):\\r\\n letter_count[char] = (letter_count[char] / s_length) * 100\\r\\n print(char, \\\"{:.1f}%\\\".format(letter_count[char]))\",\n \"def calculateValue(name):\\n\\tscore = 0\\n\\tfor c in name:\\n\\t\\tscore += ord(c) - ord('A') + 1\\n\\treturn score\",\n \"def add_word_count(self):\\n self.dataframe['word_count'] = self.dataframe.letter.str.count('\\\\w+')\",\n \"def count(text):\\n return len(text)\",\n \"def duplicate_count(text: str) -> int:\\n\\n max_count = 0\\n char_exclude = []\\n for char in text:\\n if char.isalpha():\\n text = text.replace(char, char.lower())\\n char = char.lower()\\n if char not in char_exclude and text.count(char) > 1:\\n char_exclude.append(char)\\n max_count += 1\\n return max_count\",\n \"def theLoveLetterMystery(s):\\n mincount = 0\\n for i in range(len(s) // 2):\\n mincount += abs(ord(s[i]) - ord(s[-1 - i]))\\n\\n return mincount\",\n \"def count(self, char):\\n return self._sequence.count(char)\",\n \"def letternum(letter):\\n if not isinstance(letter, str):\\n raise TypeError(\\\"Invalid letter provided.\\\")\\n if not len(letter) == 1:\\n raise ValueError(\\\"Invalid letter length provided.\\\")\\n letter = letter.lower()\\n alphaletters = string.ascii_lowercase\\n for i in range(len(alphaletters)):\\n if letter[0] == alphaletters[i]:\\n return i + 1\",\n \"def count_exclamations(txt):\\n count = 0\\n for c in txt:\\n if c == '!':\\n count += 1\\n return count\",\n \"def repeatedString(s, n):\\n\\n count = 0\\n s_count_a = s.count('a')\\n\\n count += math.floor(n / len(s)) * s_count_a\\n for _ in range(n % len(s)):\\n if s[_] == 'a':\\n count += 1\\n\\n return count\",\n \"def countAll(word):\\n counts = {}\\n for char in word.lower():\\n if char not in counts:\\n counts[char] = 1\\n else:\\n counts[char] += 1\\n return counts\",\n \"def main():\\n\\n numBob = 0\\n i = 0\\n\\n for letters in s:\\n if i < (len(s)-2):\\n if letters == 'b':\\n if s[i+1] == 'o':\\n if s[i+2] == 'b':\\n numBob += 1\\n i = i +1\\n\\n\\n print('Number of times bob occurs is: ' + str(numBob))\",\n \"def count(self):\\n return len(self.names)\",\n \"def countCharacters(self, words, chars):\\n chars_dict = self.count_to_dict(chars)\\n chars_set = chars_dict.keys()\\n len_chars_set = len(chars_set)\\n \\n good_string = ''\\n for words_i in words:\\n word_dict = self.count_to_dict(words_i)\\n words_i_set = word_dict.keys()\\n check = 0\\n for i in words_i_set:\\n if i not in chars_set:\\n check+=1\\n break\\n if word_dict[i] > chars_dict[i]:\\n check+=1\\n break\\n if check == 1:\\n continue\\n good_string = good_string+words_i\\n return len(good_string)\",\n \"def test_aabcdd():\\n assert part_01.count_for('abbcdd', 2) == 1\\n assert part_01.count_for('aabcdd', 3) == 0\",\n \"def numLetterCount(maxNum):\\n sum = 0\\n for num in range(1,maxNum+1):\\n sum += len(num2words(num))\\n print(str(num) + ' = ' + str(num2words(num)))\\n return sum\",\n \"def num_mismatched_letters(self, word1:str, word2:str)-> int:\\n assert(len(word1) == len(word2))\\n count = 0\\n # -----------------------------------------\\n # TODO: You need to write this method.\\n\\n\\n # -----------------------------------------\\n return count\",\n \"def letter_freq(txt):\\n frequencies = {}\\n txt_lower = txt.lower()\\n\\n for i in txt_lower:\\n keys = frequencies.keys()\\n if i in keys:\\n frequencies[i] += 1\\n else:\\n frequencies[i] = 1\\n return frequencies\",\n \"def length(s: str) -> int:\\n count = 0\\n for i in s:\\n count += 1\\n return count\",\n \"def test_number_in_word():\\n assert syllapy.count(\\\"d0g\\\") == 0\",\n \"def countWord(afz, word, output=True):\\n count = 0\\n for msg in msgs:\\n if msg.afz == afz:\\n count = count + msg.msg.lower().count(word.lower())\\n print afz, 'heeft', count, 'keer', word, 'gezegd.'\",\n \"def tally_letters(string):\\n output = dict()\\n for char in list(string):\\n freq = output.get(char, 0)\\n output[char]= freq+1\\n return output\",\n \"def namelength(self):\\n return self[\\\"namelength\\\"]\",\n \"def test_abbcde():\\n assert part_01.count_for('abbcde', 2) == 1\\n assert part_01.count_for('abbcde', 3) == 0\",\n \"def letterCount(dict):\\n # Making a new dictionary to store each letter's information in\\n letters = dict.fromkeys(string.ascii_lowercase, 0)\\n total = 0\\n\\n # Populating the letters-totals dictionary\\n for key in dict:\\n for letter in key:\\n letters[letter] += dict[key].getNumber()\\n # Total to keep track of all letters\\n total += dict[key].getNumber()\\n\\n # Changing the letter-total data to letter-frequency data\\n for entry in letters:\\n letters[entry] = letters[entry] / total\\n\\n return letters\",\n \"def duplicate_count(text):\\n n = 0\\n for c in set(text.lower()):\\n if text.lower().count(c) > 1:\\n n += 1\\n return n\",\n \"def letter_name(index):\\n letters = string.ascii_lowercase\\n count = len(letters)\\n\\n return letters[index % count] * ((index // count) + 1)\",\n \"def gapRunCount(letters):\\n uniqLetters = map(operator.itemgetter(0), groupby(letters))\\n return uniqLetters.count(\\\"-\\\")\",\n \"def most_repeating_letter_count(word):\\n return Counter(word.lower()).most_common(1)[0][1]\",\n \"def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\\n return Counter(_naked_names_iter(graph))\",\n \"def letter_text_analyzer(text, letter):\\n count = 0\\n text_mod = \\\"\\\"\\n for char in text:\\n if char not in string.punctuation:\\n text_mod += char\\n text_split = text_mod.split()\\n\\n for word in text_split:\\n if letter in word:\\n count += 1\\n result = \\\"Your text contains {0} words,of which {1} ({2:.1%}) contain an '{3}'\\\"\\n\\n return result.format(len(text_split), count, count / len(text_split), letter)\",\n \"def check_unique_name(first_letters, count, name, unique_list, suffix=False):\\n if suffix:\\n while name in unique_list:\\n count += 1\\n end_count = \\\"%03d\\\" % count\\n name = name[:-3] + end_count\\n else:\\n while name in unique_list:\\n count += 1\\n end_count = \\\"%06d\\\" % count\\n name = first_letters + \\\"_\\\" + end_count\\n\\n return name, count\",\n \"def nwords(s: str):\\n letters = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\\\"\\n take = 0\\n skip = 0\\n for i in s:\\n if i not in letters:\\n skip += 1\\n #print(\\\"S:\\\", skip)\\n else:\\n take += 1\\n #print(\\\"t:\\\", take)\\n res = (len(s) - take) + 1\\n return res\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-s\\\", help=\\\"String to be used as list of letters (to be counted)\\\")\\n args = parser.parse_args()\\n counts = counter(list(args.s))\\n print counts\",\n \"def words_capital_letter(self, path, filemoving, parser):\\n root = parser.parsing_xml(path, filemoving)\\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\\n number_of_words_capital_letter = 0\\n for i in root.iter(root_tag+'p'):\\n if str(type(i.text)) == \\\"<class 'str'>\\\":\\n number_of_words_capital_letter = number_of_words_capital_letter + sum(list(map(lambda x: x.istitle(), i.text.split())))\\n return number_of_words_capital_letter\",\n \"def num_char(lista):\\n all_c = \\\"\\\"\\n for i in lista:\\n all_c += str(i)\\n return len(all_c)\",\n \"def vowelcount(string):\\n string = string.upper()\\n i = string.count('A')\\n i = i + string.count('E')\\n i = i + string.count('I')\\n i = i + string.count('O')\\n i = i + string.count('U')\\n i = i + string.count('Ä')\\n i = i + string.count('Ö')\\n i = i + string.count('Ü')\\n print(string, \\\"contains \\\", i, \\\" vowels\\\")\",\n \"def test_char_count_returns_a_dict(self):\\n self.assertIsInstance(char_count(\\\"aaabbc\\\"), dict)\",\n \"def count_upper_case(message):\\n return sum([1 for c in message if c.isupper()])\",\n \"def calc_word_score(word, letters_count, letters_score):\\n\\n output = 0\\n # keep track of the used letters\\n letters_remaining = dict(letters_count)\\n\\n for w in word:\\n if w not in letters_count:\\n # contains a letter outside the provided scope\\n return 0\\n if letters_remaining[w] == 0:\\n # too many occurrences of that letter\\n return 0\\n output += letters_score[w]\\n letters_remaining[w] -= 1\\n\\n return output\",\n \"def letterFreq(words):\\n dict = {}\\n total = 0\\n for word in words:#Iterate through words\\n for letter in word:#Increment by letter\\n count = 0\\n for yearCount in words[word]:\\n count += yearCount.count#Increment total instances of word\\n total += count#Count total letters\\n if letter in dict:\\n dict[letter] += count#Add to existing entry\\n else:\\n dict[letter] = count#Create new entry\\n \\\"\\\"\\\"CODE FOR THE WHOLE ALPHABET\\\"\\\"\\\"\\n list = []\\n for letter in ascii_lowercase:\\n if letter in dict and dict[letter] != 0:\\n list.append(dict[letter] / total)#Convert to relative\\n else:\\n list.append(0.0)#Fill alphabet\\n return list\",\n \"def heading_count(self, phrase,char='~'):\\r\\n count = 0\\r\\n for x in phrase:\\r\\n if x != char:\\r\\n break\\r\\n count+=1\\r\\n return count,phrase[count:]\",\n \"def atomic_number(name):\\n try:\\n return symbols.index(name.capitalize()) + 1\\n except ValueError:\\n return lower_names.index(name.lower()) + 1\",\n \"def _nth_letter(n):\\r\\n\\treturn string.ascii_lowercase[n % len(string.ascii_lowercase)]\",\n \"def duplicate_count(val):\\n new_ls = []\\n ls = []\\n for char in val.lower():\\n if char not in new_ls:\\n new_ls.append(char)\\n else:\\n ls.append(char)\\n return len(set(ls))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75467575","0.74104375","0.74040395","0.739459","0.73699015","0.7357591","0.7343402","0.7343402","0.7343402","0.7343402","0.731937","0.7260459","0.72601306","0.72523135","0.72024745","0.7005587","0.69186723","0.6886823","0.68676317","0.68437684","0.67980176","0.67924356","0.6752559","0.67480206","0.67263204","0.67036337","0.6677373","0.66684824","0.66530716","0.6608531","0.65499187","0.6500356","0.64595115","0.645609","0.64522886","0.643468","0.64285475","0.64151603","0.6412389","0.641056","0.6388657","0.63691705","0.63443667","0.6341905","0.6316096","0.63077015","0.6281753","0.6277172","0.6266555","0.6256427","0.6251601","0.6234564","0.6233346","0.62330884","0.622926","0.6224635","0.6224412","0.6205295","0.6197304","0.6182812","0.6168487","0.6123929","0.60961485","0.60862577","0.6073387","0.6063459","0.606028","0.605522","0.60308015","0.6011921","0.6007771","0.60053664","0.60015947","0.6000994","0.5992754","0.59837496","0.59797287","0.59576595","0.59420127","0.59419245","0.59363216","0.59190446","0.5906642","0.59036726","0.5895424","0.5886453","0.587737","0.58701456","0.5867321","0.5855194","0.58513916","0.5847085","0.5846209","0.5822352","0.58211994","0.581642","0.5808705","0.58075345","0.5805044","0.58002675"],"string":"[\n \"0.75467575\",\n \"0.74104375\",\n \"0.74040395\",\n \"0.739459\",\n \"0.73699015\",\n \"0.7357591\",\n \"0.7343402\",\n \"0.7343402\",\n \"0.7343402\",\n \"0.7343402\",\n \"0.731937\",\n \"0.7260459\",\n \"0.72601306\",\n \"0.72523135\",\n \"0.72024745\",\n \"0.7005587\",\n \"0.69186723\",\n \"0.6886823\",\n \"0.68676317\",\n \"0.68437684\",\n \"0.67980176\",\n \"0.67924356\",\n \"0.6752559\",\n \"0.67480206\",\n \"0.67263204\",\n \"0.67036337\",\n \"0.6677373\",\n \"0.66684824\",\n \"0.66530716\",\n \"0.6608531\",\n \"0.65499187\",\n \"0.6500356\",\n \"0.64595115\",\n \"0.645609\",\n \"0.64522886\",\n \"0.643468\",\n \"0.64285475\",\n \"0.64151603\",\n \"0.6412389\",\n \"0.641056\",\n \"0.6388657\",\n \"0.63691705\",\n \"0.63443667\",\n \"0.6341905\",\n \"0.6316096\",\n \"0.63077015\",\n \"0.6281753\",\n \"0.6277172\",\n \"0.6266555\",\n \"0.6256427\",\n \"0.6251601\",\n \"0.6234564\",\n \"0.6233346\",\n \"0.62330884\",\n \"0.622926\",\n \"0.6224635\",\n \"0.6224412\",\n \"0.6205295\",\n \"0.6197304\",\n \"0.6182812\",\n \"0.6168487\",\n \"0.6123929\",\n \"0.60961485\",\n \"0.60862577\",\n \"0.6073387\",\n \"0.6063459\",\n \"0.606028\",\n \"0.605522\",\n \"0.60308015\",\n \"0.6011921\",\n \"0.6007771\",\n \"0.60053664\",\n \"0.60015947\",\n \"0.6000994\",\n \"0.5992754\",\n \"0.59837496\",\n \"0.59797287\",\n \"0.59576595\",\n \"0.59420127\",\n \"0.59419245\",\n \"0.59363216\",\n \"0.59190446\",\n \"0.5906642\",\n \"0.59036726\",\n \"0.5895424\",\n \"0.5886453\",\n \"0.587737\",\n \"0.58701456\",\n \"0.5867321\",\n \"0.5855194\",\n \"0.58513916\",\n \"0.5847085\",\n \"0.5846209\",\n \"0.5822352\",\n \"0.58211994\",\n \"0.581642\",\n \"0.5808705\",\n \"0.58075345\",\n \"0.5805044\",\n \"0.58002675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74775517"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":23497,"cells":{"query":{"kind":"string","value":"Converts the given str (str_in) to a datetime.date or datetime.datetime object, using the format optionally given as the parameter format_in."},"document":{"kind":"string","value":"def str2date(str_in, format_in=\"yyyy-mm-dd\", typeout=None):\n if type(str_in) is not str:\n raise TypeError(\"str_in must be a str\")\n if type(format_in) is not str:\n raise TypeError(\"format_in must be a str\")\n if typeout is not dt.date and typeout is not dt.datetime and typeout is not None:\n raise TypeError(\"typeout must be datetime.date, datetime.datetime, or None\")\n\n # Parse the parts of the date (year, month, day, hour, minute, second)\n # Three letter month (Jan, Feb, etc) and two number years need special\n # handling\n\n # First check if the string AM or PM is present in the input date time string,\n # this will indicate that the hour needs to be adjusted\n ampm_match = re.search(\"[aApP][mM]\", str_in)\n if ampm_match is None:\n hr24_bool = True\n else:\n hr24_bool = False\n ampm_str = ampm_match.group(0).lower()\n\n\n # Try finding four number year first (because 'yy' will match 'yyyy' too)\n # If there isn't even a two letter year, set the year to the current one\n yr = __substr_to_int(str_in, format_in, \"yyyy\")\n if yr == 0:\n yr = __substr_to_int(str_in, format_in, \"yy\", def_val=None) # must use None because 00 is a legitimate year\n if yr is None:\n yr = dt.date.today().year\n else:\n curr_yr_tmp = dt.date.today().year\n curr_yr = curr_yr_tmp % 100\n curr_century = curr_yr_tmp - curr_yr\n if yr <= curr_yr:\n yr = yr + curr_century\n else:\n yr = yr + curr_century - 100\n\n # Similar approach for months, except that for three letter months, we\n # need to convert from name to number. Default to Jan if no month given\n mn = __substr_to_month(str_in, format_in) # always searches for \"mmm\"\n if mn is None:\n mn = __substr_to_int(str_in, format_in, \"mm\")\n if mn == 0:\n mn = 1\n\n # Similar again for day, except that it can only ever be specified as \"dd\"\n dy = __substr_to_int(str_in, format_in, \"dd\")\n if dy == 0:\n dy = 1\n\n # Hour, minute, and second are easier because they can be 0...\n hour = __substr_to_int(str_in, format_in, \"HH\")\n # ... but hour needs to handle AM/PM. Afternoon needs 12 hours added\n # (1:00 PM = 1300 hr, 8:00 = 2000 hr, etc) but noon should stay 12 and\n # midnight (12 AM) should become hour = 0\n if not hr24_bool:\n if hour < 1 or hour > 12:\n raise ValueError(\"If using AM/PM format, hour must be between 1 and 12\")\n elif hour != 12 and ampm_str == \"pm\":\n hour += 12\n elif hour == 12 and ampm_str == \"am\":\n hour = 0\n minute = __substr_to_int(str_in, format_in, \"MM\")\n second = __substr_to_int(str_in, format_in, \"SS\")\n\n # If no type out specified, it will be date only if hour, minute, and second\n # are all 0\n if typeout is None:\n if hour == 0 and minute == 0 and second == 0:\n typeout = dt.date\n else:\n typeout = dt.datetime\n\n if typeout is dt.date:\n return dt.date(yr, mn, dy)\n elif typeout is dt.datetime:\n return dt.datetime(yr, mn, dy, hour, minute, second)\n else:\n raise RuntimeError(\"Not implemented: typeout other than datetime.date or datetime.datetime\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_date_from_string(self, datestr, fmt):\n return datetime.datetime.strptime(datestr, fmt)","def str2date(date_str, date_format):\n return datetime.strptime(date_str, date_format)","def _convert_date(date_string, s_format='%Y-%m-%d'):\r\n if isinstance(date_string, str):\r\n return datetime.strptime(date_string, s_format)\r\n elif isinstance(date_string, datetime):\r\n return date_string\r\n else:\r\n raise TypeError(date_string, 'is not a string or datetime object')","def str_to_date(str_input):\n date = str_input.split('-')\n return dt.date(int(date[0]), int(date[1]), int(date[2]))","def from_format(cls, date_string: str, format_string: str) -> Date:\n from .datetime_ import DateTime\n return DateTime.strptime(date_string, format_string).date()","def parse_datetime(datetime_str: Text) -> datetime.datetime:\n for str_format in cfg.datetime_str_formats:\n try:\n datetime_object = datetime.datetime.strptime(datetime_str, str_format)\n return datetime_object\n except ValueError:\n continue","def parse_datetime(dt_str, format):\n t = time.strptime(dt_str, format)\n return datetime(t[0], t[1], t[2], t[3], t[4], t[5], t[6], pytz.UTC)","def _parse(self, date_str, format='%Y-%m-%d'):\n from pandas import to_datetime\n rv = to_datetime(date_str, format=format)\n if hasattr(rv, 'to_datetime'):\n rv = rv.to_datetime()\n return rv","def get_strptime(date_string: str) -> dt.datetime:\n return dt.datetime.strptime(date_string, get_settings().datetime_format)","def _string_to_date(datestr,fmt):\n if not isinstance(datestr,str):\n raise InstrumentParameterException('Value %s is not a string.' % str(datestr))\n try:\n date_time = time.strptime(datestr,fmt)\n date = (date_time[2],date_time[1],date_time[0])\n\n except ValueError:\n raise InstrumentParameterException('Value %s could not be formatted to a date.' % str(datestr))\n \n return date","def parse(string, format):\n # Count the number of spaces in the format string (N), and\n # truncate everything after the (N+1)th space\n spaces = format.count(' ') + 1\n string = ' '.join(string.split()[:spaces])\n\n try:\n result = dt.datetime.strptime(string, format)\n except ValueError, err:\n raise CannotParse(str(err))\n else:\n return result","def _parse_date(date_string: str) -> Union[datetime.datetime, str]:\n for date_format in KNOWN_DATE_FORMATS:\n try:\n date = datetime.datetime.strptime(date_string, date_format)\n return date\n except ValueError:\n continue\n return date_string","def str2date(string):\n if string is 'None':\n return None\n return datetime.strptime(string + '000', '%Y-%m-%dT%H:%M:%S.%f')","def _get_date_from_str(date_input):\r\n return datetime.datetime.strptime(date_input.strip(), \"%Y-%m-%d\").replace(tzinfo=pytz.UTC)","def parse_completion_date(self, in_str):\n if in_str:\n try:\n self.completion_date = datetime.strptime(in_str, DATE_FORMAT)\n except ValueError:\n self.completion_date = None\n else:\n self.completion_date = None","def datetime_from_string(date_string):\n try:\n return datetime.datetime.strptime(date_string, date_format)\n except Exception as e:\n print(\"Got exception parsing date {} with format {} {}\"\n .format(date_string, date_format, e))","def parse_creation_date(self, in_str):\n if in_str:\n try:\n self.creation_date = datetime.strptime(in_str, DATE_FORMAT)\n except ValueError:\n self.creation_date = None\n else:\n self.creation_date = None","def dpn_strptime(dt_string):\n return datetime.strptime(dt_string, DPN_DATE_FORMAT)","def decode_datetime(self, string):\n if isinstance(string, str):\n if 'T' in string:\n return datetime.strptime(string, \"%Y%m%dT%H%M%S\")\n else:\n return datetime.strptime(string, \"%Y%m%d\")\n else:\n return string","def str2date(s):\n return datetime.strptime(s.decode(), \"%Y-%m-%d %H:%M:%S\")","def str_to_datetime(datestr):\n\n from dateutil import parser\n from datetime import datetime\n\n date = parser.parse(datestr)\n return date","def str_to_date(date_string, fmt=\"%Y-%m-%d\"):\n return datetime.strptime(date_string, fmt).date()","def parse_datetime(date_str: str) -> datetime:\n return dateutil.parser.parse(date_str)","def str_to_date(str):\n if not str:\n return str\n return datetime.datetime.strptime(str, DEFAULT_SERVER_DATE_FORMAT).date()","def stringToDate(str):\n format = '%m/%d/%Y:%H:%M'\n try:\n newDate = datetime.datetime.strptime(str, format)\n return newDate\n except ValueError as e:\n print('Invalid format. Type --help for help.')\n sys.exit()","def str_to_date(st):\r\n return datetime.strptime(st, '%Y-%m-%dT%H:%M:%S.%fZ')","def convert_datestring_to_datetime(datestring, format=DATETIME_FORMAT):\n time_struct = strptime(datestring, format)\n return datetime(*time_struct[0:6])","def date_parse(date_string) -> datetime:\n return datetime.strptime(date_string, DATE_FMT)","def strptime(cls, date_string, format):\n import _strptime # type: ignore\n\n return _strptime._strptime_datetime(cls, date_string, format)","def csv_str_to_date(datestr: str) -> datetime:\n return datetime.strptime(datestr, \"%Y-%b-%d %I:%M %p\")","def parse_date_input(input, formats=DT_INPUT_FORMATS):\n\n for fmt in formats:\n try:\n return datetime.datetime.strptime(input, fmt)\n except (ValueError):\n pass\n raise ValueError(\"'%(input)s' is not a valid datetime.\" % vars())","def to_datetime(dt_str):\n return datetime.datetime.strptime(dt_str, \"%Y-%m-%dT%H:%M:%S.%f\")","def str_to_datetime(str):\n\n\treturn (datetime.strptime(str, \"%Y-%m-%dT%H:%M:%S.%fZ\"))","def string_to_date(string):\n params = string.strip().split('-')\n year = int(params[0])\n month = int(params[1])\n day = int(params[2])\n d = date(year, month, day)\n return d","def parse_known_date_formats(dt_string):\n for fmt in ('%Y%m%d', '%Y%m%d %H:%M', '%m/%d/%Y', '%m/%d/%Y %H:%M'):\n try:\n return datetime.strptime(dt_string, fmt)\n except ValueError:\n pass\n raise ValueError(\"No valid date format found.\"\n \"See https://tidesandcurrents.noaa.gov/api/ \"\n \"for list of accepted date formats.\")","def str_to_datetime(str):\n if not str:\n return str\n return datetime.datetime.strptime(str.split(\".\")[0], DEFAULT_SERVER_DATETIME_FORMAT)","def format_date(data, format_string='%Y-%m-%d'):\n if (data == '') or 'BC' in data:\n return None\n return datetime.strptime(data, format_string)","def genesis_to_datetime(genesis_str):\n date = None\n for date_format in ['%m/%d/%y %I:%M%p', '%m/%d/%Y']:\n try:\n date = datetime.strptime(genesis_str, date_format)\n break\n except ValueError:\n pass\n return date","def str_to_date_find(st):\r\n return datetime.strptime(st, '%Y-%m-%dT%H:%M:%SZ')","def to_date(str):\n \n try:\n return datetime.datetime.strptime(str,\"%Y/%m/%d %H:%M\")\n except ValueError:\n return datetime.datetime.strptime(str,\"%Y/%m/%d\")","def iso_from_string(inp):\n try: r=inp.split(\".\")[0]\n except: r=inp\n fmt=\"%Y-%m-%dT%H:%M:%S\"\n return datetime.strptime(r, fmt)","def str_2_date(str_date):\n str_format = \"%m/%d/%y\"\n return datetime.strptime(str_date, str_format)","def parse_date_arg(date_arg):\n return datetime.datetime.strptime(date_arg, DATE_FORMAT)","def _date_from_str(self, date_entry, date_str):\n dt_obj = None\n if date_str:\n dt_obj = parser.parse(date_str)\n if dt_obj < MIN_DATE or dt_obj > MAX_DATE:\n prompt = 'Please keep dates within Jan 1, 2015 up to today.'\n raise ValueError(prompt)\n \n return dt_obj","def convert_string_to_datetime(date_string):\n REGEX_1 = \"^[0-9]{1,2}\\s[a-zA-Z]{3}\\s[0-9]{4}\\s[0-9]{2}\\:[0-9]{2}\\:[0-9]{2}\\s\\+[0-9]{4}$\"\n REGEX_2 = \"^[a-zA-Z]{3}\\,\\s[0-9]{1,2}\\s[a-zA-Z]{3}\\s[0-9]{4}\\s[0-9]{2}\\:[0-9]{2}\\:[0-9]{2}\\s\\+[0-9]{4}$\"\n REGEX_3 = \"^[a-zA-Z]{3}\\,\\s[0-9]{1,2}\\s[a-zA-Z]{3}\\s[0-9]{4}\\s[0-9]{2}\\:[0-9]{2}\\:[0-9]{2}\\s\\+[0-9]{4}\\s\\([a-zA-Z]{3}\\)$\"\n\n if re.match(REGEX_1, date_string):\n return datetime.strptime(date_string, '%d %b %Y %H:%M:%S %z')\n elif re.match(REGEX_2, date_string):\n return datetime.strptime(date_string, '%a, %d %b %Y %H:%M:%S %z')\n elif re.match(REGEX_3, date_string):\n return datetime.strptime(date_string, '%a, %d %b %Y %H:%M:%S %z (%Z)')\n else:\n return None","def str_to_date(date_str: str) -> Optional[datetime.date]:\n if not date_str:\n # If the type is falsy, return None.\n return\n try:\n # Most dates in the API are in this format...\n return datetime.strptime(date_str, \"%m/%d/%Y\").date()\n except ValueError:\n # Please forgive me for this nested try-except block.\n # This API is _whack_.\n try:\n # But some are in this format...\n return datetime.strptime(date_str, \"%Y-%m-%d\").date()\n except ValueError:\n # And sometimes you get random crap like '0000-00-00'...\n return\n except TypeError:\n # If the type is truthy, but can't be cast to a date, return None.\n return","def str_to_datetime(str_repr):\n # Allow the caller to be stupid.\n if type(str_repr) == datetime.datetime:\n return str_repr\n if not str_repr:\n return None\n return ciso8601.parse_datetime(str_repr)","def str_to_date(date_as_str):\n date_time_obj = datetime.datetime.strptime(date_as_str, '%Y-%m-%d').date()\n return date_time_obj","def _get_datetime_from_format(dt_value, dt_format):\n result = None\n try:\n result = datetime.datetime.strptime(dt_value, dt_format)\n except ValueError:\n pass\n return result","def parse_date(date_string, format):\n try:\n return datetime.strptime(date_string, format)\n except ValueError:\n return None","def _datetime_obj_from_string(date_string, date_only=False):\n str_format = \"%Y-%m-%d %H:%M:%S\"\n if date_only is True:\n str_format = \"%Y-%m-%d\"\n\n return datetime.strptime(date_string, str_format)","def parse_date(date_str, date_format=DATE_FORMAT):\n if date_str is None:\n return None\n return pd.datetime.strptime(date_str, '%Y%m%d')","def parse_date(date_str: str,\n date_format: Optional[str] = None) -> Optional[Union[datetime.datetime,\n datetime.timedelta,\n datetime.time]]:\n formats = [\"%Y-%m-%d\", \"%m/%d/%y\", \"%m/%d/%Y\", \"%b %Y\", \"%b %y\", \"%m/xx/%y\",\n \"%a %b %d %Y\", \"%B %d %Y %H:%M\", \"%b %d %Y %H:%M\",\n \"%B %d %Y\", \"%b %d %Y\", '%a %b %d, %Y',\n \"%Y-%m-%d %H:%M:%S%z\"\n ]\n if date_format is not None:\n formats.insert(0, date_format)\n if not isinstance(date_str, str):\n date_str = str(date_str)\n try:\n return from_isodatetime(date_str)\n except ValueError:\n pass\n tzinfo = datetime.timedelta(0)\n if re.match(r'.+\\s+ES?T$', date_str):\n tzinfo = datetime.timedelta(hours=5)\n elif re.match(r'.+\\s+EDT$', date_str):\n tzinfo = datetime.timedelta(hours=4)\n elif re.match(r'.+\\s+PS?T$', date_str):\n tzinfo = datetime.timedelta(hours=8)\n elif re.match(r'.+\\s+PDT$', date_str):\n tzinfo = datetime.timedelta(hours=7)\n dte = date_str\n for regex, sub in date_hacks:\n dte = regex.sub(sub, dte)\n for fmt in formats:\n try:\n retval = datetime.datetime.strptime(dte, fmt)\n if '%z' not in fmt:\n retval += tzinfo\n return retval\n except ValueError:\n pass\n return datetime.datetime(*(time.strptime(date_str)[0:6]))","def convert_str_to_date(date_str):\n if date_str.lower() == 'tomorrow':\n return datetime.date.today() + datetime.timedelta(days=1)\n elif date_str.lower() == 'today':\n return datetime.date.today()\n elif date_str.lower() == 'yesterday':\n return datetime.date.today() + datetime.timedelta(days=-1)\n elif date_str.lower() in day_values:\n return next_weekday(date_str)\n # Otherwise, process as a three-part date\n part_list = date_str.split()\n day = part_list[1].replace('th', '').replace('rd', '').replace('st', '')\n processed_date_str = ' '.join([part_list[0], day, part_list[2]])\n return datetime.datetime.strptime(processed_date_str, DATE_STR_FMT).date()","def make_datetime_from_string(string):\n return datetime.datetime.strptime(string, \"%Y-%m-%dT%H:%M:%S%z\")","def str_to_date(date_str):\r\n\r\n if date_str == 'today':\r\n date = datetime.date.today()\r\n else:\r\n date = datetime.datetime.strptime(date_str, \"%Y-%m-%d\").date()\r\n\r\n return date","def get_date(date_string):\n return datetime.datetime.strptime(date_string.split('T')[0], \"%Y-%m-%d\")","def parseIBDatetime(s: str) -> Union[dt.date, dt.datetime]:\n if len(s) == 8:\n # YYYYmmdd\n y = int(s[0:4])\n m = int(s[4:6])\n d = int(s[6:8])\n t = dt.date(y, m, d)\n elif s.isdigit():\n t = dt.datetime.fromtimestamp(int(s), dt.timezone.utc)\n elif s.count(' ') >= 2 and ' ' not in s:\n # 20221125 10:00:00 Europe/Amsterdam\n s0, s1, s2 = s.split(' ', 2)\n t = dt.datetime.strptime(s0 + s1, '%Y%m%d%H:%M:%S')\n t = t.replace(tzinfo=ZoneInfo(s2))\n else:\n # YYYYmmdd HH:MM:SS\n # or\n # YYYY-mm-dd HH:MM:SS.0\n ss = s.replace(' ', '').replace('-', '')[:16]\n t = dt.datetime.strptime(ss, '%Y%m%d%H:%M:%S')\n return t","def convert_date(date_str):\n return datetime.strptime(date_str, \"%d/%m/%Y\")","def from_iso(dt_str):\n return datetime.datetime.strptime(dt_str, ISO_FORMAT)","def to_date(d, date_format = \"%Y-%m-%d %H:%M:%S.%f\"):\n if type(d) == pd.core.series.Series:\n d = list(d)\n if type(d) == list:\n return [datetime.strptime(date,date_format) if type(date) == str else date for date in d]\n elif type(d) == str:\n return datetime.strptime(d,date_format)\n else:\n raise ValueError(\"Either String or list of Strings is accepted.\")","def datetime_fromstr(timestr: str) -> GPSTime:\n\n return datetime.strptime(timestr, \"%Y-%m-%d\")","def str_to_date(date):\n time_format_one = \"%Y-%m-%d\"\n if date is None:\n return None\n try:\n date = datetime.strptime(date, time_format_one)\n except ValueError:\n date = datetime.now()\n return date","def date_from_string(date):\n _type = type(date)\n try:\n if _type == datetime.date:\n return date\n elif _type == datetime.datetime:\n return datetime.datetime.date(date)\n else:\n return datetime.datetime.date(datetime.datetime.strptime(date, '%Y-%m-%d'))\n except ValueError:\n return date\n except TypeError:\n return date","def str_to_datetime(self, dt_string):\n return datetime.datetime.strptime(dt_string, \"%Y-%m-%d\").replace(\n tzinfo=timezone.utc) if dt_string is not None else datetime.datetime.utcnow()","def date_from_string(my_string):\n if my_string:\n return datetime.strptime(my_string, DATE_FORMAT).date()\n return None","def datestr_parse(date_str):\n\n fmt_lst = ['%Y%m%dT%H:%M:%S', '%Y%m%dT%H:%M', '%Y%m%d']\n dtime = None\n def _get_dtime(fmt):\n try:\n return dt.datetime.strptime(date_str, fmt)\n except ValueError:\n return dtime\n\n for fmt in fmt_lst:\n dtime = _get_dtime(fmt)\n if dtime!=None:\n break\n\n if dtime is None:\n msg = \"date_str ***{}*** could not properly be handled!\".format(date_str)\n raise RuntimeError(msg)\n\n return dtime","def _parse_date(date_str: str) -> datetime:\n datetime_obj = datetime.strptime(date_str, \"%Y-%m-%dT%H:%M:%SZ\")\n return f\"<t:{int(datetime_obj.timestamp())}:d>\"","def datemake(datestring):\n return dtt.datetime.strptime(datestring,'%m/%d/%Y')","def try_strptime(s: str, fmt: str) -> datetime.datetime:\n try:\n return datetime.datetime.strptime(s, fmt)\n except ValueError:\n return None","def convert_date_run(datestring):\n if isinstance(datestring, datetime.date):\n return datestring\n\n try:\n return datetime.datetime.strptime(datestring, \"%Y-%m-%d\").date()\n except ValueError:\n try:\n return datetime.datetime.strptime(datestring, \"%m/%d/%Y\").date()\n except ValueError:\n # ISO 8601 without timezone\n return datetime.datetime.strptime(datestring, \"%Y-%m-%dT%H:%M:%S\").date()","def convert_str2date(date):\n import datetime\n date = str(date)\n year = int(date[0:4])\n month = int(date[4:6])\n day = int(date[6:8])\n return datetime.datetime(year,month,day)","def to_datetime(date_string):\n return dt.strptime(date_string, '%Y-%m-%d')","def get_date_from_string(date_string: str) -> datetime:\n regex = r'^(January|February|March?|April|May|June|July|August|September|October|November|December)' \\\n r' (\\d{1,2})(st|nd|rd|th), (\\d{4}) by $'\n\n if re.match(regex, date_string) is None:\n raise DateStringFormatMismatch('Scraper.get_date_from_string()', date_string)\n\n date_list = date_string.split(' ')\n\n if len(date_list[1]) == 5: # i.e. '11st,' with comma\n date_list[1] = date_list[1][0:2]\n else: # i.e '2nd,' no zero prefix because ordinal date\n date_list[1] = date_list[1][0:1].zfill(1)\n\n new_date_string = ' '.join(date_list[0:3]) # new date extracted by removing 'by', spaces and commas\n date = datetime.strptime(new_date_string, '%B %d %Y')\n date = date.replace(tzinfo=python_timezone.utc) # localizing to avoid comparison error when sorting later\n return date","def parse_date_str(self, date_str, date_format=None):\n if not date_format:\n date_format = self.parsing_date_format\n result = datetime.datetime.strptime(date_str, date_format).date()\n if result.year < 1900:\n # we have a typo in the house. Just use 2000 + last-two-digits\n year = (result.year % 100) + 2000\n result = result.replace(year=year)\n return result","def _str_to_date(self, date):\n return datetools.date_parser(date)","def rfc3339str_to_datetime(rfc3339_str):\n\n ret = None\n for fmt in rfc3339_date_input_fmts:\n try:\n ret = datetime.datetime.strptime(rfc3339_str, fmt)\n # Force this since the formats we support are all utc formats, to support non-utc\n if ret.tzinfo is None:\n ret = ret.replace(tzinfo=datetime.timezone.utc)\n continue\n except:\n pass\n\n if ret is None:\n raise Exception(\"could not convert input created_at value ({}) into datetime using formats in {}\".format(rfc3339_str, rfc3339_date_input_fmts))\n\n return ret","def parse_date(text):\n\n for fmt in ('%Y-%m-%d', '%d-%m-%Y'):\n try:\n return datetime.datetime.strptime(text, fmt)\n except ValueError:\n pass\n\n raise ValueError('Dates should be in YYYY-MM-DD or DD-MM-YYYY format')","def str_2_date( sdate ):\r\n if isinstance( sdate, str ):\r\n for fmt in ( \"%Y-%m-%d\", \"%m/%d/%Y\" ):\r\n try:\r\n return datetime.strptime( sdate, fmt ).date()\r\n except ValueError:\r\n pass\r\n else:\r\n return sdate","def str_to_datetime(dt: Union[str, datetime]) -> datetime:\n if isinstance(dt, str):\n match = re.match(\n r\"^(\\d{4})-(\\d\\d)-(\\d\\d)[T ](\\d\\d):(\\d\\d)\"\n r\"(?:\\:(\\d\\d(?:\\.\\d{1,6})?))?([+-]\\d\\d:?\\d\\d|Z)$\",\n dt,\n )\n if not match:\n raise ValueError(\"String does not match expected time format\")\n year, month, day = match[1], match[2], match[3]\n hour, minute, second = match[4], match[5], match[6]\n tz = match[7]\n if not second:\n second = 0\n microsecond = 0\n else:\n flt_second = float(second)\n second = floor(flt_second)\n microsecond = round((flt_second - second) * 1_000_000)\n result = datetime(\n int(year),\n int(month),\n int(day),\n int(hour),\n int(minute),\n int(second),\n microsecond,\n timezone.utc,\n )\n if tz != \"Z\":\n tz_sgn = int(tz[0] + \"1\")\n tz_hours = int(tz[1:3])\n tz_mins = int(tz[-2:])\n if tz_hours or tz_mins:\n result = result - timedelta(minutes=tz_sgn * (tz_hours * 60 + tz_mins))\n return result\n return dt","def string_object_to_datetime(dataframe):\n\n print(\"Which variable would you like to convert from a date string to a python date?\")\n existing_variable = input()\n print(\"What would you like to call the new date variable?\")\n new_variable = input()\n\n dataframe[new_variable] = datetime.strptime(dataframe[existing_variable], '%Y-%m-%d')\n\n return dataframe","def parse_datetime(dt_str):\n\n if not dt_str or dt_str == DELETE_VALUE:\n return None\n try:\n return datetime.strptime(dt_str, _BULK_DATETIME_FORMAT)\n except Exception:\n return datetime.strptime(dt_str, _BULK_DATETIME_FORMAT_2)","def convert_str_date(date, current_pattern, output_pattern):\n assert isinstance(date, str)\n assert isinstance(current_pattern, str)\n assert isinstance(output_pattern, str)\n\n dt = datetime.datetime.strptime(date, current_pattern).date()\n\n dt = dt.strftime(output_pattern)\n return dt","def parse_datetime(datestr):\r\n try:\r\n return dateutil.parser.parse(datestr).replace(tzinfo=utc)\r\n except ValueError:\r\n raise DashboardError(_(\"Unable to parse date: \") + datestr)","def deserialize_datetime(string):\n try:\n from dateutil.parser import parse\n return parse(string)\n except ImportError:\n return string","def parse_datetime(date_string: str) -> datetime:\n # Tries out any given format of DatetimeFormat enumeration\n return dateparser.parse(\n date_string, date_formats=[dt_format.value for dt_format in DatetimeFormat]\n ).replace(tzinfo=pytz.UTC)","def extract_datetime(\n datetime_str: Text, type_: Union[datetime.datetime, datetime.date]\n):\n if type_ == datetime.datetime:\n return parse_datetime(datetime_str)\n elif type_ == datetime.date:\n return parse_date(datetime_str)\n elif type_ == datetime.time:\n return parse_time(datetime_str)","def to_datetime(self, raw_date_str):\n if raw_date_str is None:\n return ''\n dateformat = '%Y-%m-%dT%H:%M:%S'\n date_str = raw_date_str\n if raw_date_str.endswith('Z'):\n date_str = date_str[:-1]\n dt = datetime.strptime(date_str, dateformat)\n return dt","def strpdate(cls, string, fmt=\"%Y/%m/%d\", lang='eng'):\n pattern = r'%({})'.format(reduce(lambda x, y: '{}|{}'.format(x, y), FORMAT_MAP.keys()))\n params = re.findall(pattern, fmt)\n if len(params) != len(set(params)):\n raise ValueError(\"Duplicate format specifier not allowed.\")\n for f in params:\n if f == 'Y':\n fmt = fmt.replace('%{}'.format(f), r'(?P<year>\\d{4})')\n elif f == 'y':\n fmt = fmt.replace('%{}'.format(f), r'(?P<year>\\d{2})')\n elif f == 'm':\n fmt = fmt.replace('%{}'.format(f), r'(?P<month>\\d{1,2})')\n elif f == 'd':\n fmt = fmt.replace('%{}'.format(f), r'(?P<day>\\d{1,2})')\n fmt = '^{}$'.format(fmt)\n if re.match(fmt, string) is None:\n raise ValueError('Mismatch in \"string\" and \"fmt\".')\n _ = {**MIN_DATE, 'lang': lang}\n _.update(re.match(fmt, string).groupdict())\n return cls(**_)","def convert_string_to_datetime(time_string):\n int_string = [int(i) for i in time_string.split('-')]\n return datetime.date(int_string[0], int_string[1], int_string[2])","def get_date(string):\r\n string = re.sub(' +', ' ', string)\r\n try:\r\n return dateutil.parser.parse(string)\r\n except (TypeError, ValueError):\r\n raise ValueError('{0!r} is not a valid date'.format(string))","def datestring_to_date(datestring):\n year, month, day = datestring.split(\"-\")\n date = datetime.date(year=int(year), month=int(month), day=int(day))\n return date","def datetimeify(t):\n if type(t) in [datetime, Timestamp]:\n return t\n fmts = ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d', '%Y %m %d %H %M %S',]\n for fmt in fmts:\n try:\n return datetime.strptime(t, fmt)\n except ValueError:\n pass\n raise ValueError(\"time data '{:s}' not a recognized format\".format(t))","def date_parser(market, datestr):\n brmonths = {'Janeiro': 1, 'Fevereiro': 2, 'Março': 3, 'Abril': 4, 'Maio': 5, 'Junho': 6, 'Julho': 7,\n 'Agosto': 8, 'Setembro': 9, 'Outubro': 10, 'Novembro': 11, 'Dezembro': 12}\n year = datetime.datetime.utcnow().year\n solrdateformat = '%Y-%m-%dT%H:%M:%SZ'\n\n try:\n if market is \"olx\":\n # target format: \"Inserido em: 15 Março às 09:41\"\n daymonth = re.search(r'([0-9]+).(' + str.join('|', brmonths.keys()) + ')', datestr)\n hourmin = re.search(r\"([0-9]+):([0-9]+)\", datestr)\n date = datetime.datetime(year, brmonths[daymonth.group(2)], int(daymonth.group(1)),\n hour=int(hourmin.group(1)), minute=int(hourmin.group(2)))\n return date.strftime(solrdateformat)\n else:\n raise ValueError(\"Market parser not found! Please set a date parser for maket {}.\".format(market))\n except ValueError as err:\n logging.debug(\"Could not parse date for {0} .Using UTC NOW... Error:{1}\".format(market, str(err)))\n return datetime.datetime.utcnow().strftime(solrdateformat)","def convert_datetime(t):\r\n try:\r\n if isinstance(t, str):\r\n converted = datetime.strptime(t, '%d-%m-%Y')\r\n # to get time in seconds:\r\n t = int(time.mktime(converted.timetuple()))\r\n return t\r\n except Exception as e:\r\n print(e)\r\n return None","def convert_to_date(dt, format):\n d_datetime = datetime.strptime(dt, format)\n d_date = date(int(d_datetime.strftime('%Y')), \n int(d_datetime.strftime('%m')), \n int(d_datetime.strftime('%d'))) # I know this is awful, I'm sorry\n return d_date","def convert_str_to_date(date: str):\n try:\n return datetime.strptime(date, \"%Y/%m/%d\").date()\n except ValueError:\n try:\n return datetime.strptime(date, \"%Y-%m-%d\").date()\n except ValueError as error:\n raise error","def filter_formatdate(val, format_str):\n if not isinstance(val, (datetime, date, time)):\n return val\n return val.strftime(format_str)","def date_parser(date_arg):\n\n return datetime.datetime.strptime(date_arg, '%Y-%m-%d')","def convert_time(cls, time_str):\n if cls.date_ignore_pattern:\n time_str = re.sub(cls.date_ignore_pattern, '', time_str)\n return datetime.strptime(time_str, cls.date_format)"],"string":"[\n \"def get_date_from_string(self, datestr, fmt):\\n return datetime.datetime.strptime(datestr, fmt)\",\n \"def str2date(date_str, date_format):\\n return datetime.strptime(date_str, date_format)\",\n \"def _convert_date(date_string, s_format='%Y-%m-%d'):\\r\\n if isinstance(date_string, str):\\r\\n return datetime.strptime(date_string, s_format)\\r\\n elif isinstance(date_string, datetime):\\r\\n return date_string\\r\\n else:\\r\\n raise TypeError(date_string, 'is not a string or datetime object')\",\n \"def str_to_date(str_input):\\n date = str_input.split('-')\\n return dt.date(int(date[0]), int(date[1]), int(date[2]))\",\n \"def from_format(cls, date_string: str, format_string: str) -> Date:\\n from .datetime_ import DateTime\\n return DateTime.strptime(date_string, format_string).date()\",\n \"def parse_datetime(datetime_str: Text) -> datetime.datetime:\\n for str_format in cfg.datetime_str_formats:\\n try:\\n datetime_object = datetime.datetime.strptime(datetime_str, str_format)\\n return datetime_object\\n except ValueError:\\n continue\",\n \"def parse_datetime(dt_str, format):\\n t = time.strptime(dt_str, format)\\n return datetime(t[0], t[1], t[2], t[3], t[4], t[5], t[6], pytz.UTC)\",\n \"def _parse(self, date_str, format='%Y-%m-%d'):\\n from pandas import to_datetime\\n rv = to_datetime(date_str, format=format)\\n if hasattr(rv, 'to_datetime'):\\n rv = rv.to_datetime()\\n return rv\",\n \"def get_strptime(date_string: str) -> dt.datetime:\\n return dt.datetime.strptime(date_string, get_settings().datetime_format)\",\n \"def _string_to_date(datestr,fmt):\\n if not isinstance(datestr,str):\\n raise InstrumentParameterException('Value %s is not a string.' % str(datestr))\\n try:\\n date_time = time.strptime(datestr,fmt)\\n date = (date_time[2],date_time[1],date_time[0])\\n\\n except ValueError:\\n raise InstrumentParameterException('Value %s could not be formatted to a date.' % str(datestr))\\n \\n return date\",\n \"def parse(string, format):\\n # Count the number of spaces in the format string (N), and\\n # truncate everything after the (N+1)th space\\n spaces = format.count(' ') + 1\\n string = ' '.join(string.split()[:spaces])\\n\\n try:\\n result = dt.datetime.strptime(string, format)\\n except ValueError, err:\\n raise CannotParse(str(err))\\n else:\\n return result\",\n \"def _parse_date(date_string: str) -> Union[datetime.datetime, str]:\\n for date_format in KNOWN_DATE_FORMATS:\\n try:\\n date = datetime.datetime.strptime(date_string, date_format)\\n return date\\n except ValueError:\\n continue\\n return date_string\",\n \"def str2date(string):\\n if string is 'None':\\n return None\\n return datetime.strptime(string + '000', '%Y-%m-%dT%H:%M:%S.%f')\",\n \"def _get_date_from_str(date_input):\\r\\n return datetime.datetime.strptime(date_input.strip(), \\\"%Y-%m-%d\\\").replace(tzinfo=pytz.UTC)\",\n \"def parse_completion_date(self, in_str):\\n if in_str:\\n try:\\n self.completion_date = datetime.strptime(in_str, DATE_FORMAT)\\n except ValueError:\\n self.completion_date = None\\n else:\\n self.completion_date = None\",\n \"def datetime_from_string(date_string):\\n try:\\n return datetime.datetime.strptime(date_string, date_format)\\n except Exception as e:\\n print(\\\"Got exception parsing date {} with format {} {}\\\"\\n .format(date_string, date_format, e))\",\n \"def parse_creation_date(self, in_str):\\n if in_str:\\n try:\\n self.creation_date = datetime.strptime(in_str, DATE_FORMAT)\\n except ValueError:\\n self.creation_date = None\\n else:\\n self.creation_date = None\",\n \"def dpn_strptime(dt_string):\\n return datetime.strptime(dt_string, DPN_DATE_FORMAT)\",\n \"def decode_datetime(self, string):\\n if isinstance(string, str):\\n if 'T' in string:\\n return datetime.strptime(string, \\\"%Y%m%dT%H%M%S\\\")\\n else:\\n return datetime.strptime(string, \\\"%Y%m%d\\\")\\n else:\\n return string\",\n \"def str2date(s):\\n return datetime.strptime(s.decode(), \\\"%Y-%m-%d %H:%M:%S\\\")\",\n \"def str_to_datetime(datestr):\\n\\n from dateutil import parser\\n from datetime import datetime\\n\\n date = parser.parse(datestr)\\n return date\",\n \"def str_to_date(date_string, fmt=\\\"%Y-%m-%d\\\"):\\n return datetime.strptime(date_string, fmt).date()\",\n \"def parse_datetime(date_str: str) -> datetime:\\n return dateutil.parser.parse(date_str)\",\n \"def str_to_date(str):\\n if not str:\\n return str\\n return datetime.datetime.strptime(str, DEFAULT_SERVER_DATE_FORMAT).date()\",\n \"def stringToDate(str):\\n format = '%m/%d/%Y:%H:%M'\\n try:\\n newDate = datetime.datetime.strptime(str, format)\\n return newDate\\n except ValueError as e:\\n print('Invalid format. Type --help for help.')\\n sys.exit()\",\n \"def str_to_date(st):\\r\\n return datetime.strptime(st, '%Y-%m-%dT%H:%M:%S.%fZ')\",\n \"def convert_datestring_to_datetime(datestring, format=DATETIME_FORMAT):\\n time_struct = strptime(datestring, format)\\n return datetime(*time_struct[0:6])\",\n \"def date_parse(date_string) -> datetime:\\n return datetime.strptime(date_string, DATE_FMT)\",\n \"def strptime(cls, date_string, format):\\n import _strptime # type: ignore\\n\\n return _strptime._strptime_datetime(cls, date_string, format)\",\n \"def csv_str_to_date(datestr: str) -> datetime:\\n return datetime.strptime(datestr, \\\"%Y-%b-%d %I:%M %p\\\")\",\n \"def parse_date_input(input, formats=DT_INPUT_FORMATS):\\n\\n for fmt in formats:\\n try:\\n return datetime.datetime.strptime(input, fmt)\\n except (ValueError):\\n pass\\n raise ValueError(\\\"'%(input)s' is not a valid datetime.\\\" % vars())\",\n \"def to_datetime(dt_str):\\n return datetime.datetime.strptime(dt_str, \\\"%Y-%m-%dT%H:%M:%S.%f\\\")\",\n \"def str_to_datetime(str):\\n\\n\\treturn (datetime.strptime(str, \\\"%Y-%m-%dT%H:%M:%S.%fZ\\\"))\",\n \"def string_to_date(string):\\n params = string.strip().split('-')\\n year = int(params[0])\\n month = int(params[1])\\n day = int(params[2])\\n d = date(year, month, day)\\n return d\",\n \"def parse_known_date_formats(dt_string):\\n for fmt in ('%Y%m%d', '%Y%m%d %H:%M', '%m/%d/%Y', '%m/%d/%Y %H:%M'):\\n try:\\n return datetime.strptime(dt_string, fmt)\\n except ValueError:\\n pass\\n raise ValueError(\\\"No valid date format found.\\\"\\n \\\"See https://tidesandcurrents.noaa.gov/api/ \\\"\\n \\\"for list of accepted date formats.\\\")\",\n \"def str_to_datetime(str):\\n if not str:\\n return str\\n return datetime.datetime.strptime(str.split(\\\".\\\")[0], DEFAULT_SERVER_DATETIME_FORMAT)\",\n \"def format_date(data, format_string='%Y-%m-%d'):\\n if (data == '') or 'BC' in data:\\n return None\\n return datetime.strptime(data, format_string)\",\n \"def genesis_to_datetime(genesis_str):\\n date = None\\n for date_format in ['%m/%d/%y %I:%M%p', '%m/%d/%Y']:\\n try:\\n date = datetime.strptime(genesis_str, date_format)\\n break\\n except ValueError:\\n pass\\n return date\",\n \"def str_to_date_find(st):\\r\\n return datetime.strptime(st, '%Y-%m-%dT%H:%M:%SZ')\",\n \"def to_date(str):\\n \\n try:\\n return datetime.datetime.strptime(str,\\\"%Y/%m/%d %H:%M\\\")\\n except ValueError:\\n return datetime.datetime.strptime(str,\\\"%Y/%m/%d\\\")\",\n \"def iso_from_string(inp):\\n try: r=inp.split(\\\".\\\")[0]\\n except: r=inp\\n fmt=\\\"%Y-%m-%dT%H:%M:%S\\\"\\n return datetime.strptime(r, fmt)\",\n \"def str_2_date(str_date):\\n str_format = \\\"%m/%d/%y\\\"\\n return datetime.strptime(str_date, str_format)\",\n \"def parse_date_arg(date_arg):\\n return datetime.datetime.strptime(date_arg, DATE_FORMAT)\",\n \"def _date_from_str(self, date_entry, date_str):\\n dt_obj = None\\n if date_str:\\n dt_obj = parser.parse(date_str)\\n if dt_obj < MIN_DATE or dt_obj > MAX_DATE:\\n prompt = 'Please keep dates within Jan 1, 2015 up to today.'\\n raise ValueError(prompt)\\n \\n return dt_obj\",\n \"def convert_string_to_datetime(date_string):\\n REGEX_1 = \\\"^[0-9]{1,2}\\\\s[a-zA-Z]{3}\\\\s[0-9]{4}\\\\s[0-9]{2}\\\\:[0-9]{2}\\\\:[0-9]{2}\\\\s\\\\+[0-9]{4}$\\\"\\n REGEX_2 = \\\"^[a-zA-Z]{3}\\\\,\\\\s[0-9]{1,2}\\\\s[a-zA-Z]{3}\\\\s[0-9]{4}\\\\s[0-9]{2}\\\\:[0-9]{2}\\\\:[0-9]{2}\\\\s\\\\+[0-9]{4}$\\\"\\n REGEX_3 = \\\"^[a-zA-Z]{3}\\\\,\\\\s[0-9]{1,2}\\\\s[a-zA-Z]{3}\\\\s[0-9]{4}\\\\s[0-9]{2}\\\\:[0-9]{2}\\\\:[0-9]{2}\\\\s\\\\+[0-9]{4}\\\\s\\\\([a-zA-Z]{3}\\\\)$\\\"\\n\\n if re.match(REGEX_1, date_string):\\n return datetime.strptime(date_string, '%d %b %Y %H:%M:%S %z')\\n elif re.match(REGEX_2, date_string):\\n return datetime.strptime(date_string, '%a, %d %b %Y %H:%M:%S %z')\\n elif re.match(REGEX_3, date_string):\\n return datetime.strptime(date_string, '%a, %d %b %Y %H:%M:%S %z (%Z)')\\n else:\\n return None\",\n \"def str_to_date(date_str: str) -> Optional[datetime.date]:\\n if not date_str:\\n # If the type is falsy, return None.\\n return\\n try:\\n # Most dates in the API are in this format...\\n return datetime.strptime(date_str, \\\"%m/%d/%Y\\\").date()\\n except ValueError:\\n # Please forgive me for this nested try-except block.\\n # This API is _whack_.\\n try:\\n # But some are in this format...\\n return datetime.strptime(date_str, \\\"%Y-%m-%d\\\").date()\\n except ValueError:\\n # And sometimes you get random crap like '0000-00-00'...\\n return\\n except TypeError:\\n # If the type is truthy, but can't be cast to a date, return None.\\n return\",\n \"def str_to_datetime(str_repr):\\n # Allow the caller to be stupid.\\n if type(str_repr) == datetime.datetime:\\n return str_repr\\n if not str_repr:\\n return None\\n return ciso8601.parse_datetime(str_repr)\",\n \"def str_to_date(date_as_str):\\n date_time_obj = datetime.datetime.strptime(date_as_str, '%Y-%m-%d').date()\\n return date_time_obj\",\n \"def _get_datetime_from_format(dt_value, dt_format):\\n result = None\\n try:\\n result = datetime.datetime.strptime(dt_value, dt_format)\\n except ValueError:\\n pass\\n return result\",\n \"def parse_date(date_string, format):\\n try:\\n return datetime.strptime(date_string, format)\\n except ValueError:\\n return None\",\n \"def _datetime_obj_from_string(date_string, date_only=False):\\n str_format = \\\"%Y-%m-%d %H:%M:%S\\\"\\n if date_only is True:\\n str_format = \\\"%Y-%m-%d\\\"\\n\\n return datetime.strptime(date_string, str_format)\",\n \"def parse_date(date_str, date_format=DATE_FORMAT):\\n if date_str is None:\\n return None\\n return pd.datetime.strptime(date_str, '%Y%m%d')\",\n \"def parse_date(date_str: str,\\n date_format: Optional[str] = None) -> Optional[Union[datetime.datetime,\\n datetime.timedelta,\\n datetime.time]]:\\n formats = [\\\"%Y-%m-%d\\\", \\\"%m/%d/%y\\\", \\\"%m/%d/%Y\\\", \\\"%b %Y\\\", \\\"%b %y\\\", \\\"%m/xx/%y\\\",\\n \\\"%a %b %d %Y\\\", \\\"%B %d %Y %H:%M\\\", \\\"%b %d %Y %H:%M\\\",\\n \\\"%B %d %Y\\\", \\\"%b %d %Y\\\", '%a %b %d, %Y',\\n \\\"%Y-%m-%d %H:%M:%S%z\\\"\\n ]\\n if date_format is not None:\\n formats.insert(0, date_format)\\n if not isinstance(date_str, str):\\n date_str = str(date_str)\\n try:\\n return from_isodatetime(date_str)\\n except ValueError:\\n pass\\n tzinfo = datetime.timedelta(0)\\n if re.match(r'.+\\\\s+ES?T$', date_str):\\n tzinfo = datetime.timedelta(hours=5)\\n elif re.match(r'.+\\\\s+EDT$', date_str):\\n tzinfo = datetime.timedelta(hours=4)\\n elif re.match(r'.+\\\\s+PS?T$', date_str):\\n tzinfo = datetime.timedelta(hours=8)\\n elif re.match(r'.+\\\\s+PDT$', date_str):\\n tzinfo = datetime.timedelta(hours=7)\\n dte = date_str\\n for regex, sub in date_hacks:\\n dte = regex.sub(sub, dte)\\n for fmt in formats:\\n try:\\n retval = datetime.datetime.strptime(dte, fmt)\\n if '%z' not in fmt:\\n retval += tzinfo\\n return retval\\n except ValueError:\\n pass\\n return datetime.datetime(*(time.strptime(date_str)[0:6]))\",\n \"def convert_str_to_date(date_str):\\n if date_str.lower() == 'tomorrow':\\n return datetime.date.today() + datetime.timedelta(days=1)\\n elif date_str.lower() == 'today':\\n return datetime.date.today()\\n elif date_str.lower() == 'yesterday':\\n return datetime.date.today() + datetime.timedelta(days=-1)\\n elif date_str.lower() in day_values:\\n return next_weekday(date_str)\\n # Otherwise, process as a three-part date\\n part_list = date_str.split()\\n day = part_list[1].replace('th', '').replace('rd', '').replace('st', '')\\n processed_date_str = ' '.join([part_list[0], day, part_list[2]])\\n return datetime.datetime.strptime(processed_date_str, DATE_STR_FMT).date()\",\n \"def make_datetime_from_string(string):\\n return datetime.datetime.strptime(string, \\\"%Y-%m-%dT%H:%M:%S%z\\\")\",\n \"def str_to_date(date_str):\\r\\n\\r\\n if date_str == 'today':\\r\\n date = datetime.date.today()\\r\\n else:\\r\\n date = datetime.datetime.strptime(date_str, \\\"%Y-%m-%d\\\").date()\\r\\n\\r\\n return date\",\n \"def get_date(date_string):\\n return datetime.datetime.strptime(date_string.split('T')[0], \\\"%Y-%m-%d\\\")\",\n \"def parseIBDatetime(s: str) -> Union[dt.date, dt.datetime]:\\n if len(s) == 8:\\n # YYYYmmdd\\n y = int(s[0:4])\\n m = int(s[4:6])\\n d = int(s[6:8])\\n t = dt.date(y, m, d)\\n elif s.isdigit():\\n t = dt.datetime.fromtimestamp(int(s), dt.timezone.utc)\\n elif s.count(' ') >= 2 and ' ' not in s:\\n # 20221125 10:00:00 Europe/Amsterdam\\n s0, s1, s2 = s.split(' ', 2)\\n t = dt.datetime.strptime(s0 + s1, '%Y%m%d%H:%M:%S')\\n t = t.replace(tzinfo=ZoneInfo(s2))\\n else:\\n # YYYYmmdd HH:MM:SS\\n # or\\n # YYYY-mm-dd HH:MM:SS.0\\n ss = s.replace(' ', '').replace('-', '')[:16]\\n t = dt.datetime.strptime(ss, '%Y%m%d%H:%M:%S')\\n return t\",\n \"def convert_date(date_str):\\n return datetime.strptime(date_str, \\\"%d/%m/%Y\\\")\",\n \"def from_iso(dt_str):\\n return datetime.datetime.strptime(dt_str, ISO_FORMAT)\",\n \"def to_date(d, date_format = \\\"%Y-%m-%d %H:%M:%S.%f\\\"):\\n if type(d) == pd.core.series.Series:\\n d = list(d)\\n if type(d) == list:\\n return [datetime.strptime(date,date_format) if type(date) == str else date for date in d]\\n elif type(d) == str:\\n return datetime.strptime(d,date_format)\\n else:\\n raise ValueError(\\\"Either String or list of Strings is accepted.\\\")\",\n \"def datetime_fromstr(timestr: str) -> GPSTime:\\n\\n return datetime.strptime(timestr, \\\"%Y-%m-%d\\\")\",\n \"def str_to_date(date):\\n time_format_one = \\\"%Y-%m-%d\\\"\\n if date is None:\\n return None\\n try:\\n date = datetime.strptime(date, time_format_one)\\n except ValueError:\\n date = datetime.now()\\n return date\",\n \"def date_from_string(date):\\n _type = type(date)\\n try:\\n if _type == datetime.date:\\n return date\\n elif _type == datetime.datetime:\\n return datetime.datetime.date(date)\\n else:\\n return datetime.datetime.date(datetime.datetime.strptime(date, '%Y-%m-%d'))\\n except ValueError:\\n return date\\n except TypeError:\\n return date\",\n \"def str_to_datetime(self, dt_string):\\n return datetime.datetime.strptime(dt_string, \\\"%Y-%m-%d\\\").replace(\\n tzinfo=timezone.utc) if dt_string is not None else datetime.datetime.utcnow()\",\n \"def date_from_string(my_string):\\n if my_string:\\n return datetime.strptime(my_string, DATE_FORMAT).date()\\n return None\",\n \"def datestr_parse(date_str):\\n\\n fmt_lst = ['%Y%m%dT%H:%M:%S', '%Y%m%dT%H:%M', '%Y%m%d']\\n dtime = None\\n def _get_dtime(fmt):\\n try:\\n return dt.datetime.strptime(date_str, fmt)\\n except ValueError:\\n return dtime\\n\\n for fmt in fmt_lst:\\n dtime = _get_dtime(fmt)\\n if dtime!=None:\\n break\\n\\n if dtime is None:\\n msg = \\\"date_str ***{}*** could not properly be handled!\\\".format(date_str)\\n raise RuntimeError(msg)\\n\\n return dtime\",\n \"def _parse_date(date_str: str) -> datetime:\\n datetime_obj = datetime.strptime(date_str, \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n return f\\\"<t:{int(datetime_obj.timestamp())}:d>\\\"\",\n \"def datemake(datestring):\\n return dtt.datetime.strptime(datestring,'%m/%d/%Y')\",\n \"def try_strptime(s: str, fmt: str) -> datetime.datetime:\\n try:\\n return datetime.datetime.strptime(s, fmt)\\n except ValueError:\\n return None\",\n \"def convert_date_run(datestring):\\n if isinstance(datestring, datetime.date):\\n return datestring\\n\\n try:\\n return datetime.datetime.strptime(datestring, \\\"%Y-%m-%d\\\").date()\\n except ValueError:\\n try:\\n return datetime.datetime.strptime(datestring, \\\"%m/%d/%Y\\\").date()\\n except ValueError:\\n # ISO 8601 without timezone\\n return datetime.datetime.strptime(datestring, \\\"%Y-%m-%dT%H:%M:%S\\\").date()\",\n \"def convert_str2date(date):\\n import datetime\\n date = str(date)\\n year = int(date[0:4])\\n month = int(date[4:6])\\n day = int(date[6:8])\\n return datetime.datetime(year,month,day)\",\n \"def to_datetime(date_string):\\n return dt.strptime(date_string, '%Y-%m-%d')\",\n \"def get_date_from_string(date_string: str) -> datetime:\\n regex = r'^(January|February|March?|April|May|June|July|August|September|October|November|December)' \\\\\\n r' (\\\\d{1,2})(st|nd|rd|th), (\\\\d{4}) by $'\\n\\n if re.match(regex, date_string) is None:\\n raise DateStringFormatMismatch('Scraper.get_date_from_string()', date_string)\\n\\n date_list = date_string.split(' ')\\n\\n if len(date_list[1]) == 5: # i.e. '11st,' with comma\\n date_list[1] = date_list[1][0:2]\\n else: # i.e '2nd,' no zero prefix because ordinal date\\n date_list[1] = date_list[1][0:1].zfill(1)\\n\\n new_date_string = ' '.join(date_list[0:3]) # new date extracted by removing 'by', spaces and commas\\n date = datetime.strptime(new_date_string, '%B %d %Y')\\n date = date.replace(tzinfo=python_timezone.utc) # localizing to avoid comparison error when sorting later\\n return date\",\n \"def parse_date_str(self, date_str, date_format=None):\\n if not date_format:\\n date_format = self.parsing_date_format\\n result = datetime.datetime.strptime(date_str, date_format).date()\\n if result.year < 1900:\\n # we have a typo in the house. Just use 2000 + last-two-digits\\n year = (result.year % 100) + 2000\\n result = result.replace(year=year)\\n return result\",\n \"def _str_to_date(self, date):\\n return datetools.date_parser(date)\",\n \"def rfc3339str_to_datetime(rfc3339_str):\\n\\n ret = None\\n for fmt in rfc3339_date_input_fmts:\\n try:\\n ret = datetime.datetime.strptime(rfc3339_str, fmt)\\n # Force this since the formats we support are all utc formats, to support non-utc\\n if ret.tzinfo is None:\\n ret = ret.replace(tzinfo=datetime.timezone.utc)\\n continue\\n except:\\n pass\\n\\n if ret is None:\\n raise Exception(\\\"could not convert input created_at value ({}) into datetime using formats in {}\\\".format(rfc3339_str, rfc3339_date_input_fmts))\\n\\n return ret\",\n \"def parse_date(text):\\n\\n for fmt in ('%Y-%m-%d', '%d-%m-%Y'):\\n try:\\n return datetime.datetime.strptime(text, fmt)\\n except ValueError:\\n pass\\n\\n raise ValueError('Dates should be in YYYY-MM-DD or DD-MM-YYYY format')\",\n \"def str_2_date( sdate ):\\r\\n if isinstance( sdate, str ):\\r\\n for fmt in ( \\\"%Y-%m-%d\\\", \\\"%m/%d/%Y\\\" ):\\r\\n try:\\r\\n return datetime.strptime( sdate, fmt ).date()\\r\\n except ValueError:\\r\\n pass\\r\\n else:\\r\\n return sdate\",\n \"def str_to_datetime(dt: Union[str, datetime]) -> datetime:\\n if isinstance(dt, str):\\n match = re.match(\\n r\\\"^(\\\\d{4})-(\\\\d\\\\d)-(\\\\d\\\\d)[T ](\\\\d\\\\d):(\\\\d\\\\d)\\\"\\n r\\\"(?:\\\\:(\\\\d\\\\d(?:\\\\.\\\\d{1,6})?))?([+-]\\\\d\\\\d:?\\\\d\\\\d|Z)$\\\",\\n dt,\\n )\\n if not match:\\n raise ValueError(\\\"String does not match expected time format\\\")\\n year, month, day = match[1], match[2], match[3]\\n hour, minute, second = match[4], match[5], match[6]\\n tz = match[7]\\n if not second:\\n second = 0\\n microsecond = 0\\n else:\\n flt_second = float(second)\\n second = floor(flt_second)\\n microsecond = round((flt_second - second) * 1_000_000)\\n result = datetime(\\n int(year),\\n int(month),\\n int(day),\\n int(hour),\\n int(minute),\\n int(second),\\n microsecond,\\n timezone.utc,\\n )\\n if tz != \\\"Z\\\":\\n tz_sgn = int(tz[0] + \\\"1\\\")\\n tz_hours = int(tz[1:3])\\n tz_mins = int(tz[-2:])\\n if tz_hours or tz_mins:\\n result = result - timedelta(minutes=tz_sgn * (tz_hours * 60 + tz_mins))\\n return result\\n return dt\",\n \"def string_object_to_datetime(dataframe):\\n\\n print(\\\"Which variable would you like to convert from a date string to a python date?\\\")\\n existing_variable = input()\\n print(\\\"What would you like to call the new date variable?\\\")\\n new_variable = input()\\n\\n dataframe[new_variable] = datetime.strptime(dataframe[existing_variable], '%Y-%m-%d')\\n\\n return dataframe\",\n \"def parse_datetime(dt_str):\\n\\n if not dt_str or dt_str == DELETE_VALUE:\\n return None\\n try:\\n return datetime.strptime(dt_str, _BULK_DATETIME_FORMAT)\\n except Exception:\\n return datetime.strptime(dt_str, _BULK_DATETIME_FORMAT_2)\",\n \"def convert_str_date(date, current_pattern, output_pattern):\\n assert isinstance(date, str)\\n assert isinstance(current_pattern, str)\\n assert isinstance(output_pattern, str)\\n\\n dt = datetime.datetime.strptime(date, current_pattern).date()\\n\\n dt = dt.strftime(output_pattern)\\n return dt\",\n \"def parse_datetime(datestr):\\r\\n try:\\r\\n return dateutil.parser.parse(datestr).replace(tzinfo=utc)\\r\\n except ValueError:\\r\\n raise DashboardError(_(\\\"Unable to parse date: \\\") + datestr)\",\n \"def deserialize_datetime(string):\\n try:\\n from dateutil.parser import parse\\n return parse(string)\\n except ImportError:\\n return string\",\n \"def parse_datetime(date_string: str) -> datetime:\\n # Tries out any given format of DatetimeFormat enumeration\\n return dateparser.parse(\\n date_string, date_formats=[dt_format.value for dt_format in DatetimeFormat]\\n ).replace(tzinfo=pytz.UTC)\",\n \"def extract_datetime(\\n datetime_str: Text, type_: Union[datetime.datetime, datetime.date]\\n):\\n if type_ == datetime.datetime:\\n return parse_datetime(datetime_str)\\n elif type_ == datetime.date:\\n return parse_date(datetime_str)\\n elif type_ == datetime.time:\\n return parse_time(datetime_str)\",\n \"def to_datetime(self, raw_date_str):\\n if raw_date_str is None:\\n return ''\\n dateformat = '%Y-%m-%dT%H:%M:%S'\\n date_str = raw_date_str\\n if raw_date_str.endswith('Z'):\\n date_str = date_str[:-1]\\n dt = datetime.strptime(date_str, dateformat)\\n return dt\",\n \"def strpdate(cls, string, fmt=\\\"%Y/%m/%d\\\", lang='eng'):\\n pattern = r'%({})'.format(reduce(lambda x, y: '{}|{}'.format(x, y), FORMAT_MAP.keys()))\\n params = re.findall(pattern, fmt)\\n if len(params) != len(set(params)):\\n raise ValueError(\\\"Duplicate format specifier not allowed.\\\")\\n for f in params:\\n if f == 'Y':\\n fmt = fmt.replace('%{}'.format(f), r'(?P<year>\\\\d{4})')\\n elif f == 'y':\\n fmt = fmt.replace('%{}'.format(f), r'(?P<year>\\\\d{2})')\\n elif f == 'm':\\n fmt = fmt.replace('%{}'.format(f), r'(?P<month>\\\\d{1,2})')\\n elif f == 'd':\\n fmt = fmt.replace('%{}'.format(f), r'(?P<day>\\\\d{1,2})')\\n fmt = '^{}$'.format(fmt)\\n if re.match(fmt, string) is None:\\n raise ValueError('Mismatch in \\\"string\\\" and \\\"fmt\\\".')\\n _ = {**MIN_DATE, 'lang': lang}\\n _.update(re.match(fmt, string).groupdict())\\n return cls(**_)\",\n \"def convert_string_to_datetime(time_string):\\n int_string = [int(i) for i in time_string.split('-')]\\n return datetime.date(int_string[0], int_string[1], int_string[2])\",\n \"def get_date(string):\\r\\n string = re.sub(' +', ' ', string)\\r\\n try:\\r\\n return dateutil.parser.parse(string)\\r\\n except (TypeError, ValueError):\\r\\n raise ValueError('{0!r} is not a valid date'.format(string))\",\n \"def datestring_to_date(datestring):\\n year, month, day = datestring.split(\\\"-\\\")\\n date = datetime.date(year=int(year), month=int(month), day=int(day))\\n return date\",\n \"def datetimeify(t):\\n if type(t) in [datetime, Timestamp]:\\n return t\\n fmts = ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d', '%Y %m %d %H %M %S',]\\n for fmt in fmts:\\n try:\\n return datetime.strptime(t, fmt)\\n except ValueError:\\n pass\\n raise ValueError(\\\"time data '{:s}' not a recognized format\\\".format(t))\",\n \"def date_parser(market, datestr):\\n brmonths = {'Janeiro': 1, 'Fevereiro': 2, 'Março': 3, 'Abril': 4, 'Maio': 5, 'Junho': 6, 'Julho': 7,\\n 'Agosto': 8, 'Setembro': 9, 'Outubro': 10, 'Novembro': 11, 'Dezembro': 12}\\n year = datetime.datetime.utcnow().year\\n solrdateformat = '%Y-%m-%dT%H:%M:%SZ'\\n\\n try:\\n if market is \\\"olx\\\":\\n # target format: \\\"Inserido em: 15 Março às 09:41\\\"\\n daymonth = re.search(r'([0-9]+).(' + str.join('|', brmonths.keys()) + ')', datestr)\\n hourmin = re.search(r\\\"([0-9]+):([0-9]+)\\\", datestr)\\n date = datetime.datetime(year, brmonths[daymonth.group(2)], int(daymonth.group(1)),\\n hour=int(hourmin.group(1)), minute=int(hourmin.group(2)))\\n return date.strftime(solrdateformat)\\n else:\\n raise ValueError(\\\"Market parser not found! Please set a date parser for maket {}.\\\".format(market))\\n except ValueError as err:\\n logging.debug(\\\"Could not parse date for {0} .Using UTC NOW... Error:{1}\\\".format(market, str(err)))\\n return datetime.datetime.utcnow().strftime(solrdateformat)\",\n \"def convert_datetime(t):\\r\\n try:\\r\\n if isinstance(t, str):\\r\\n converted = datetime.strptime(t, '%d-%m-%Y')\\r\\n # to get time in seconds:\\r\\n t = int(time.mktime(converted.timetuple()))\\r\\n return t\\r\\n except Exception as e:\\r\\n print(e)\\r\\n return None\",\n \"def convert_to_date(dt, format):\\n d_datetime = datetime.strptime(dt, format)\\n d_date = date(int(d_datetime.strftime('%Y')), \\n int(d_datetime.strftime('%m')), \\n int(d_datetime.strftime('%d'))) # I know this is awful, I'm sorry\\n return d_date\",\n \"def convert_str_to_date(date: str):\\n try:\\n return datetime.strptime(date, \\\"%Y/%m/%d\\\").date()\\n except ValueError:\\n try:\\n return datetime.strptime(date, \\\"%Y-%m-%d\\\").date()\\n except ValueError as error:\\n raise error\",\n \"def filter_formatdate(val, format_str):\\n if not isinstance(val, (datetime, date, time)):\\n return val\\n return val.strftime(format_str)\",\n \"def date_parser(date_arg):\\n\\n return datetime.datetime.strptime(date_arg, '%Y-%m-%d')\",\n \"def convert_time(cls, time_str):\\n if cls.date_ignore_pattern:\\n time_str = re.sub(cls.date_ignore_pattern, '', time_str)\\n return datetime.strptime(time_str, cls.date_format)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76346546","0.74792445","0.7137026","0.7019489","0.7005402","0.691273","0.68818885","0.687637","0.684877","0.68447477","0.6791915","0.67769426","0.6754171","0.6749142","0.672639","0.6686086","0.6681176","0.6680179","0.66634023","0.6661955","0.66202503","0.661948","0.658018","0.657376","0.6568449","0.6560795","0.65603393","0.6559709","0.65544033","0.6550526","0.6548157","0.6536667","0.65302765","0.652435","0.64909714","0.6489969","0.6481494","0.64803886","0.64729416","0.64050543","0.63967055","0.6395435","0.6388044","0.6363041","0.63622624","0.63572043","0.63425905","0.6335777","0.6333994","0.6330916","0.6316655","0.63141865","0.6313033","0.63076216","0.62970227","0.6296554","0.6281241","0.6261455","0.6242714","0.62007964","0.6193584","0.61921394","0.61867845","0.61867434","0.6184241","0.61825335","0.61733574","0.61595047","0.614067","0.61396587","0.6136967","0.61254233","0.61183167","0.6105276","0.607993","0.6067516","0.6066381","0.6065332","0.6059831","0.60495055","0.60482067","0.60369945","0.60352576","0.60335886","0.6003127","0.5996181","0.59929866","0.59849143","0.59670097","0.5956038","0.59437364","0.5937869","0.59116644","0.58917135","0.5889143","0.58841354","0.58798826","0.5871908","0.5857587","0.58539945"],"string":"[\n \"0.76346546\",\n \"0.74792445\",\n \"0.7137026\",\n \"0.7019489\",\n \"0.7005402\",\n \"0.691273\",\n \"0.68818885\",\n \"0.687637\",\n \"0.684877\",\n \"0.68447477\",\n \"0.6791915\",\n \"0.67769426\",\n \"0.6754171\",\n \"0.6749142\",\n \"0.672639\",\n \"0.6686086\",\n \"0.6681176\",\n \"0.6680179\",\n \"0.66634023\",\n \"0.6661955\",\n \"0.66202503\",\n \"0.661948\",\n \"0.658018\",\n \"0.657376\",\n \"0.6568449\",\n \"0.6560795\",\n \"0.65603393\",\n \"0.6559709\",\n \"0.65544033\",\n \"0.6550526\",\n \"0.6548157\",\n \"0.6536667\",\n \"0.65302765\",\n \"0.652435\",\n \"0.64909714\",\n \"0.6489969\",\n \"0.6481494\",\n \"0.64803886\",\n \"0.64729416\",\n \"0.64050543\",\n \"0.63967055\",\n \"0.6395435\",\n \"0.6388044\",\n \"0.6363041\",\n \"0.63622624\",\n \"0.63572043\",\n \"0.63425905\",\n \"0.6335777\",\n \"0.6333994\",\n \"0.6330916\",\n \"0.6316655\",\n \"0.63141865\",\n \"0.6313033\",\n \"0.63076216\",\n \"0.62970227\",\n \"0.6296554\",\n \"0.6281241\",\n \"0.6261455\",\n \"0.6242714\",\n \"0.62007964\",\n \"0.6193584\",\n \"0.61921394\",\n \"0.61867845\",\n \"0.61867434\",\n \"0.6184241\",\n \"0.61825335\",\n \"0.61733574\",\n \"0.61595047\",\n \"0.614067\",\n \"0.61396587\",\n \"0.6136967\",\n \"0.61254233\",\n \"0.61183167\",\n \"0.6105276\",\n \"0.607993\",\n \"0.6067516\",\n \"0.6066381\",\n \"0.6065332\",\n \"0.6059831\",\n \"0.60495055\",\n \"0.60482067\",\n \"0.60369945\",\n \"0.60352576\",\n \"0.60335886\",\n \"0.6003127\",\n \"0.5996181\",\n \"0.59929866\",\n \"0.59849143\",\n \"0.59670097\",\n \"0.5956038\",\n \"0.59437364\",\n \"0.5937869\",\n \"0.59116644\",\n \"0.58917135\",\n \"0.5889143\",\n \"0.58841354\",\n \"0.58798826\",\n \"0.5871908\",\n \"0.5857587\",\n \"0.58539945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73334426"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":23498,"cells":{"query":{"kind":"string","value":"Try to get the date that a file was created, falling back to when it was last modified if that isn't possible."},"document":{"kind":"string","value":"def created(path):\n\n # TODO: Test this code block on other platforms (OS X/Linux)\n\n if platform.system() == 'Windows':\n date = datetime.fromtimestamp(os.path.getctime(path)).strftime('%Y-%m-%d')\n return date\n\n else:\n stat = os.stat(path)\n\n try:\n return stat.st_birthtime\n\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _creation_date(path_to_file):\n if platform.system() == \"Windows\":\n return os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime","def creation_date(path_to_file):\n if platform.system() == 'Windows':\n return os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n return stat.st_mtime","def creation_date(path_to_file):\n if platform.system() == 'Windows':\n print(\"last modified: %s\" % time.ctime(os.path.getmtime(path_to_file)))\n modtime = time.ctime(os.path.getmtime(path_to_file))\n \n print(\"created: %s\" % time.ctime(os.path.getctime(path_to_file)))\n modtime = datetime.datetime.strptime(modtime, \"%a %b %d %H:%M:%S %Y\")\n modtime = datetime.datetime.strftime(modtime, \"%Y-%m-%d\")\n return modtime","def creation_date(path_to_file):\n if platform.system() == 'Windows':\n return os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime","def creation_date(path_to_file):\n if platform.system() == 'Windows':\n return os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime","def creation_date(file_path):\n date = None\n if platform.system() == 'Windows':\n try:\n date = os.path.getctime(file_path)\n except FileNotFoundError:\n print('FileNotFoundError: ' + file_path)\n UTILITIES_LOGGER.error('FileNotFoundError: ' + file_path)\n else:\n try:\n stat = os.stat(file_path)\n try:\n date = stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n date = stat.st_mtime\n except FileNotFoundError as e:\n print('FileNotFoundError: ' + file_path)\n UTILITIES_LOGGER.exception('FileNotFoundError: ' + file_path)\n # return datetime.datetime.fromtimestamp(int(date)).strftime('%Y-%m-%d %H:%M:%S')\n # Got error: OverflowError: timestamp out of range for platform time_t\n # When manually testing with existing files from Windows. Probably not an issue in real\n # usage, but fixed anyway with datetime.datetime.utcfromtimestamp().\n # See: https://stackoverflow.com/questions/3682748/converting-unix-timestamp-string-to-readable-date#comment30046351_3682808\n try:\n return datetime.datetime.utcfromtimestamp(int(date)).strftime('%Y-%m-%d %H:%M:%S')\n except OverflowError as e:\n # Getting OverflowError when testing with some files, not sure of root cause\n # This perhaps is only a problem when the file is read on creation when copied to sesison directory.\n # It gets read a second time when modified. Need to wait for the copy to finish?\n print('OverflowError: date value: ' + str(date) + ' for file:' + file_path)\n UTILITIES_LOGGER.exception('OverflowError: date:' + str(date) + ' file:' + file_path)\n return None","def creation_date(path_to_file, return_datetime=True):\n if platform.system() == 'Windows':\n created_at = os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n created_at = stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n created_at = stat.st_mtime\n\n if return_datetime:\n return datetime.fromtimestamp(created_at)\n else:\n return created_at","def get_file_date(self, file: str) -> date:","def file_creation_date(file_path):\n # Must be a valid path string\n assert os.path.isfile(file_path) is True\n\n unix_timestamp = os.path.getctime(file_path)\n\n return datetime.fromtimestamp(unix_timestamp)","def creation_date(path):\n if platform.system() == 'Windows':\n return os.path.getctime(path)\n else:\n stat = os.stat(path)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime","def creation_date(filename):\n try:\n if filename.endswith(JPEG_EXTENSIONS):\n timestamp = creation_date_from_exif(filename)\n else:\n timestamp = creation_date_from_hachoir(filename)\n except ValueError:\n timestamp = None\n\n try:\n path_date = creation_date_from_path(filename)\n except ValueError:\n return timestamp\n\n if not timestamp:\n return path_date\n\n # Preserve path timestamp if incompatible with image timestamp\n if timestamp < path_date - timedelta(days=2):\n return path_date\n if timestamp > path_date + timedelta(days=1):\n return path_date\n\n return timestamp","def creation_date_from_path(filename):\n try:\n return _find_datetime(os.path.basename(filename))\n except ValueError:\n pass\n\n try:\n return _find_date(os.path.basename(filename)[:10])\n except ValueError:\n pass\n\n try:\n return _find_date(os.path.basename(filename))\n except ValueError:\n pass\n\n try:\n return _find_date(os.path.dirname(filename))\n except ValueError:\n pass\n\n raise ValueError(f\"No date found in path for {filename}\")","def getCreationDate(filename):\r\n path = cachePath(filename)\r\n \r\n pe = pefile.PE(path)\r\n return datetime.fromtimestamp(pe.FILE_HEADER.TimeDateStamp)","def creation_date_video(path_to_file):\n print(\"Last modified: %s\" % time.ctime(os.path.getmtime(path_to_file)))\n print(\"Created: %s\" % time.ctime(os.path.getctime(path_to_file)))\n # return os.path.getctime(path_to_file)","def findcreatedate(self):\n try:\n exifdata = subprocess.check_output(['exiftool', '-j', '-TAG', '-CreateDate', self.filename])\n except OSError as e:\n print \"exiftool may not be installed. Please go check.\"\n print \"Here is the error thrown: {}\".format(e)\n raise\n\n data = json.loads(exifdata)\n self.createdate = date(*[int(elt) for elt in re.split('[ :]', data[0]['CreateDate'])][0:3])\n return self.createdate","def created(self) -> datetime.datetime:\n # REMARK: On Unix systems getctime() returns the time of most recent\n # metadata change, but not the creation.\n # https://stackoverflow.com/questions/237079/how-do-i-get-file-creation-and-modification-date-times\n # https://docs.python.org/3/library/os.html#os.stat_result\n if platform.system() == \"Windows\":\n timestamp = os.path.getctime(self._manifest_path)\n\n else:\n stat = os.stat(self._manifest_path)\n try:\n timestamp = stat.st_birthtime\n except AttributeError:\n timestamp = stat.st_mtime\n\n return datetime.datetime.fromtimestamp(timestamp)","def get_file_modification_date() -> str:\n file_modification_date = datetime.now().strftime(\"%d.%m.%Y\")\n print(file_modification_date)\n return file_modification_date","def get_file_modified_date(filepath):\n return datetime.datetime.fromtimestamp(os.path.getmtime(filepath))","def _get_date_modified(path):\n return str(datetime.datetime.fromtimestamp(os.path.getmtime(path)))","def get_file_cm_time(file_path):\n try:\n create_time = os.path.getctime(file_path)\n if create_time:\n return int(create_time)\n modify_time = os.path.getmtime(file_path)\n if modify_time:\n return int(modify_time)\n except (OSError, ValueError) as e:\n logger.error('Error while get creation time of file. ERROR: %s.',\n str(e))\n return 0","def get_file_age_default(path, cur_parsed, cur_datetime):\n\tmtime = datetime.fromtimestamp(os.path.getmtime(path))\n\tmtime = str(mtime).split(' ')[0]\n\tmtime = parse_date_str(mtime, '-', 0, 1, 2)\n\tprint(\"file mtime: {}\".format(mtime))\n\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], mtime[0], mtime[1], mtime[2])\n\treturn date_dif","def creation_year(path_to_file):\n if platform.system() == 'Windows':\n print(\"last modified: %s\" % time.ctime(os.path.getmtime(path_to_file)))\n modtime = time.ctime(os.path.getmtime(path_to_file))\n \n print(\"created: %s\" % time.ctime(os.path.getctime(path_to_file)))\n modtime = datetime.datetime.strptime(modtime, \"%a %b %d %H:%M:%S %Y\")\n modtime = datetime.datetime.strftime(modtime, \"%Y\")\n return modtime","def get_file_modification_time(self, filename):\n mtime = None\n if os.path.exists(filename):\n mtime = datetime.datetime.fromtimestamp(os.path.getmtime(filename))\n return mtime","def try_utime(self, filename, last_modified_hdr):\n if last_modified_hdr is None:\n return\n if not os.path.isfile(encodeFilename(filename)):\n return\n timestr = last_modified_hdr\n if timestr is None:\n return\n filetime = timeconvert(timestr)\n if filetime is None:\n return filetime\n # Ignore obviously invalid dates\n if filetime == 0:\n return\n with contextlib.suppress(Exception):\n os.utime(filename, (time.time(), filetime))\n return filetime","def get_file_last_modification_date(filename=None):\n with open(filename, 'r') as fp:\n for line in fp:\n if line.startswith('Modify'):\n date_line = line.split()[1]\n file_date = datetime.strptime(date_line, \"%Y-%m-%d\")\n return filename, file_date","def creation_month(path_to_file):\n if platform.system() == 'Windows':\n print(\"last modified: %s\" % time.ctime(os.path.getmtime(path_to_file)))\n modtime = time.ctime(os.path.getmtime(path_to_file))\n \n print(\"created: %s\" % time.ctime(os.path.getctime(path_to_file)))\n modtime = datetime.datetime.strptime(modtime, \"%a %b %d %H:%M:%S %Y\")\n modtime = datetime.datetime.strftime(modtime, \"%B\")\n return modtime","def getDate(path):\n utime = ftp.stat(path=path).st_mtime\n last_modified = datetime.fromtimestamp(utime)\n return last_modified","def get_mtime(self):\n if not os.path.exists(self.file_name):\n return None\n st = os.stat(self.file_name)\n return st.st_mtime","def last_modified(self):\n return os.path.getmtime(self.filename)","def get_last_usage_date(path: str) -> datetime:\r\n date: datetime\r\n\r\n if not os.path.exists(path):\r\n raise FileNotFoundError(\"Path does not exist: \" + path)\r\n\r\n try:\r\n date = datetime.fromtimestamp(os.path.getmtime(path))\r\n except Exception:\r\n pass\r\n\r\n try:\r\n compare_date = datetime.fromtimestamp(os.path.getatime(path))\r\n if date.date() < compare_date.date():\r\n # compare date is newer\r\n date = compare_date\r\n except Exception:\r\n pass\r\n\r\n try:\r\n compare_date = datetime.fromtimestamp(os.path.getctime(path))\r\n if date.date() < compare_date.date():\r\n # compare date is newer\r\n date = compare_date\r\n except Exception:\r\n pass\r\n\r\n return date","def DateCreated(filepath, stringformat=False):\n time_in_s = os.path.getctime(filepath)\n if stringformat:\n return time.ctime(time_in_s)\n else:\n return time_in_s","def get_timestamp(file_path):\n mtime = os.stat(file_path).st_mtime\n return datetime.datetime.fromtimestamp(mtime).isoformat()","def creation_date_from_hachoir(filename):\n parser = createParser(filename)\n metadata = extractMetadata(parser)\n if metadata is None:\n raise ValueError(f\"Hachoir found no metadata for {filename}\")\n return metadata.get(\"creation_date\")","def creation_date_tuple(file_path):\n return file_path, creation_date(file_path)","def testCreationTime(self):\n path_spec = path_spec_factory.Factory.NewPathSpec(\n definitions.TYPE_INDICATOR_HFS,\n identifier=self._IDENTIFIER_ANOTHER_FILE,\n location='/a_directory/another_file',\n parent=self._raw_path_spec)\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\n\n self.assertIsNotNone(file_entry)\n self.assertIsNotNone(file_entry.creation_time)","def get_last_modified_date(self):\n\t\treturn call_sdk_function('PrlFsEntry_GetLastModifiedDate', self.handle)","def getmtime(self):\n if self.exists():\n return os.path.getmtime(self.path)\n return 0","def checkDateForFileName(self):\n #self.currentLocalTime was already changed in log Temperatures\n if self.currentLocalTime.tm_mday != self.currentDay:\n #the day has changed we should start a new log file!\n self.logFile = self._logFile_default()\n self._create_log_file()","def last_modified(path):\n\n date = os.path.getmtime(path)\n date = datetime.datetime.fromtimestamp(date)\n return time.mktime(date.timetuple())","def get_modified_time(fname):\n return os.stat(fname).st_mtime","def last_modified():\n return \"Last modified: %s\" % time.ctime(os.path.getmtime(FILE_NAME))","def modified(self) -> datetime:\n # TODO: Should this be overridden for LocalDirectoryAsset?\n return datetime.fromtimestamp(self.filepath.stat().st_mtime).astimezone()","def get_creation_time(self):\n return self.get_attr('date_created')","def last_modified_date_time(self):\n if \"lastModifiedDateTime\" in self._prop_dict:\n return datetime.strptime(self._prop_dict[\"lastModifiedDateTime\"].replace(\"Z\", \"\"), \"%Y-%m-%dT%H:%M:%S.%f\")\n else:\n return None","def get_creation_time(ts):\n path_to_embed_file = os.path.join(DATA_DIR, STUDY, \"experiment_files\", \"experiment_\"+ ts, \"triplet_training_validation_embeddings.h5\")\n\n if os.path.exists(path_to_embed_file):\n stat = os.stat(path_to_embed_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get creation dates here,\n # so we'll settle for when its content was last modified.\n return stat.st_mtime\n else:\n print (\"here, path is: \", path_to_embed_file)\n return None","def DateModified(filepath, stringformat=False):\n time_in_s = os.path.getmtime(filepath)\n if stringformat:\n return time.ctime(time_in_s)\n else:\n return time_in_s","def DateCreated(self, default=None):\n return self.data.get('metadata', {}).get('_created', default)","def getFileModifTime(filename):\n\tfilename = adaptPath(filename)\n\tfrom os import stat\n\ttry:\n\t\tresult = stat(filename).st_mtime\n\texcept:\n\t\tresult = 0\n\treturn result","def stat_timestamp(filename):\n return os.stat(filename).st_mtime","def _GetUpdateTime(filename):\n stat_info = os.stat(filename)\n return (stat_info.st_atime, stat_info.st_mtime)","def get_file_last_update_time(fname):\n\n try:\n lastupdate = datetime.fromtimestamp(os.stat(fname).st_mtime)\n except Exception:\n lastupdate = None\n\n return lastupdate","def timestamp(self):\n\t\tcurrent_stamp = 0\n\t\tcurrent_size = 0\n\t\ttry:\n\t\t\tst = stat(self._file)\n\t\t\tif st:\n\t\t\t\tcurrent_stamp = int(st.st_mtime)\n\t\t\t\tcurrent_size = st.st_size\n\t\t\t\t# Fake a changed mtime if size is different. Subsequent processing\n\t\t\t\t# only depends on the mtime field.\n\t\t\t\tif current_size != self._last_size:\n\t\t\t\t\tcurrent_stamp = int(time())\n\t\t\t\t\tMODULE.info(\"Size of '%s': %s -> %s\" % (self._file,self._last_size,current_size))\n\t\t\t\t\tself._last_size = current_size\n\t\tfinally:\n\t\t\tpass\n\n\t\tif current_stamp == self._last_stamp:\n\t\t\tself._unchanged_count += 1\n\t\t\tif self._unchanged_count >= self._count:\n\t\t\t\t# Don't record new timestamp if MD5 of file is the same\n\t\t\t\thash = md5(open(self._file).read()).hexdigest()\n\t\t\t\tif hash != self._last_md5:\n\t\t\t\t\tself._last_md5 = hash\n\t\t\t\t\tself._last_returned_stamp = current_stamp\n\t\t\t\telse:\n\t\t\t\t\tMODULE.info(\"Hash of '%s' unchanged\" % self._file)\n\t\telse:\n\t\t\tself._unchanged_count = 0\n\t\t\tself._last_stamp = current_stamp\n\n\t\treturn self._last_returned_stamp","def get_creation_time(self):\n return self.creation_time","def file_creation_date(file_path):\n ran_command = run_command([\"stat\", \"-f\", \"%SB\", file_path], True)\n raw_command_output = get_subprocess_output(ran_command)\n command_output = raw_command_output.strip(\"\\\\n\")\n elements = command_output.split(\" \")\n month_string = elements[0]\n month_number = 0\n day_number = int(elements[1])\n year_number = int(elements[3])\n if month_string == \"January\":\n month_number += 1\n elif month_string == \"February\":\n month_number += 2\n elif month_string == \"March\":\n month_number += 3\n elif month_string == \"April\":\n month_number += 4\n elif month_string == \"May\":\n month_number += 5\n elif month_string == \"June\":\n month_number += 6\n elif month_string == \"July\":\n month_number += 7\n elif month_string == \"August\":\n month_number += 8\n elif month_string == \"September\":\n month_number += 9\n elif month_string == \"October\":\n month_number += 10\n elif month_string == \"November\":\n month_number += 11\n elif month_string == \"December\":\n month_number += 12\n return [month_number, day_number, year_number]","def __get_modification_time(filename: str) -> float:\n return os.stat(filename).st_mtime","def modified(filename: str) -> datetime.datetime:\n fs, relative_path = url_to_fs(filename)\n return cast(datetime.datetime, fs.modified(relative_path))","def get_file_age_win(path, cur_parsed, cur_datetime):\n\ttry:\n\t\tdate_str = time.ctime(os.path.getctime(path))\n\t\tdate_parsed = parse_date_str(date_str, ' ', 4, 1, 2)\n\t\tprint(\"file crtime: {}\".format(date_parsed))\n\t\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], date_parsed[0], date_parsed[1], date_parsed[2])\n\t\treturn date_dif\n\texcept:\n\t\tprint(\"EXCEPTION! fallback to mtime!\")\n\t\treturn get_file_age_default(path, cur_parsed, cur_datetime)","def last_new_file_time(self) -> datetime.datetime:\n with self.lock:\n return self._last_new_file_time","def _get_file_mtime(self, sentry_unit, filename):\n return sentry_unit.file_stat(filename)['mtime']","def last_updated(self) -> Optional[datetime]:\n try:\n with open(self.last_updated_file) as f:\n dt = datetime.fromisoformat(f.read())\n if dt.tzinfo is None:\n dt = dt.astimezone(timezone.utc)\n return dt\n except FileNotFoundError:\n return None","def _get_date_taken(path):\n return Image.open(path)._getexif()[36867]","def get_mtime(self):\n storage = getattr(self._file, \"storage\", None)\n if storage:\n return storage.modified_time(self._file.name)\n return super(FileAsset, self).get_mtime()","def last_update(cls):\n\n import datetime, os\n from s3 import S3DateTime\n\n # Probe file (probing one is good enough since update_data\n # writes them all at the same time)\n filename = os.path.join(current.request.folder,\n \"static\", \"themes\", \"SHARE\", \"data\",\n \"people_affected.json\",\n )\n try:\n mtime = os.path.getmtime(filename)\n except OSError:\n last_update = None\n else:\n dt = datetime.datetime.utcfromtimestamp(mtime)\n last_update = S3DateTime.datetime_represent(dt, utc=True)\n\n return last_update","def last_update(cls):\n\n import datetime, os\n from s3 import S3DateTime\n\n # Probe file (probing one is good enough since update_data\n # writes them all at the same time)\n filename = os.path.join(current.request.folder,\n \"static\", \"themes\", \"SHARE\", \"data\",\n \"people_affected.json\",\n )\n try:\n mtime = os.path.getmtime(filename)\n except OSError:\n last_update = None\n else:\n dt = datetime.datetime.utcfromtimestamp(mtime)\n last_update = S3DateTime.datetime_represent(dt, utc=True)\n\n return last_update","def _get_object_mtime(self, obj):\n try:\n mtime = os.path.getmtime(inspect.getsourcefile(obj.__class__))\n except (TypeError, OSError):\n mtime = 0.\n return mtime","def getCreationTime(self): #$NON-NLS-1$\r","def creation_date_time(self) -> Optional[str]:\n return pulumi.get(self, \"creation_date_time\")","def creation_date_from_exif(filename):\n # Source: https://orthallelous.wordpress.com/2015/04/19/extracting-date-and-time-from-images-with-python/\n with Image.open(filename) as img:\n exif = img.getexif()\n\n if exif is None:\n raise ValueError(f\"No exif data for {filename}\")\n\n # for subsecond prec, see doi.org/10.3189/2013JoG12J126 , sect. 2.2, 2.3\n tags = [\n (36867, 37521), # (DateTimeOriginal, SubsecTimeOriginal)\n (36868, 37522), # (DateTimeDigitized, SubsecTimeDigitized)\n (306, 37520), # (DateTime, SubsecTime)\n ]\n\n for tag in tags:\n dat = exif.get(tag[0])\n sub = exif.get(tag[1], 0)\n\n # PIL.PILLOW_VERSION >= 3.0 returns a tuple\n dat = dat[0] if isinstance(dat, tuple) else dat\n if not dat:\n continue\n\n sub = sub[0] if isinstance(sub, tuple) else sub\n if isinstance(sub, int):\n sub = f\"{sub:06d}\"\n\n date, time = dat.split(\" \")\n date = date.replace(\":\", \"-\")\n return fromisoformat(f\"{date}T{time}.{sub}\")\n\n raise ValueError(f\"No date found in the exif data for {filename}\")","def out_of_date(original, derived):\r\n return (not os.path.exists(derived) or\r\n (os.path.exists(original) and\r\n os.stat(derived).st_mtime < os.stat(original).st_mtime))","def last_modified_date(*paths, **kwargs):\n return check_output([\n 'git',\n 'log',\n '-n', '1',\n '--pretty=format:%cd',\n '--date=iso',\n '--',\n *paths\n ], **kwargs).decode('utf-8')","def getLastModifiedTime(self): #$NON-NLS-1$\r","def last_access_time(path):\r\n return os.stat(path)[stat.ST_ATIME]","def file_get_mdatetime(filename):\n return datetime.datetime.utcfromtimestamp(os.path.getmtime(filename))","def last_date_method(self) -> datetime.datetime:\n\n try:\n with open(os.path.join(THIS_DIR, \"data_file.json\"), mode='r') as json_file:\n try:\n data = datetime.datetime.strptime(json.load(json_file)[self.site],\n '%Y-%m-%d %H:%M:%S')\n return data\n\n except:\n return datetime.datetime(1970, 1, 1)\n except:\n with open(os.path.join(THIS_DIR, \"data_file.json\"), mode='a') as json_file:\n json.dump({}, json_file)\n json_file.close()\n\n return datetime.datetime(1970, 1, 1)","def getmodtime(filename, default=None):\n if os.path.exists(filename):\n return os.stat(filename)[os.path.stat.ST_MTIME]\n else:\n return default","def creationTime(self):\n \n if not self.logMessage is None :\n return self.logMessage[\"date\"]","def check(self, name, entry):\n\n f = file(name, self.mode)\n fs = fstat(f.fileno())\n ts1 = fs[-2]\n try:\n ts2 = entry._timestamp\n except AttributeError:\n ts2 = ts1-1\n\n if ts2<ts1:\n entry._timestamp=ts1\n return f\n else:\n return None","def mtime(self):\n if self.source_file is None:\n return None\n if self._mtime is None:\n try:\n try: # Locally stored file\n mtime = os.path.getmtime(self.source_file.path)\n self._mtime = int(mtime)\n except NotImplementedError: # AWS S3 storage\n key = self.source_file.file.key\n modified = boto.utils.parse_ts(key.last_modified)\n self._mtime = int(modified.strftime('%s'))\n except (FileNotFoundError, AttributeError):\n self._mtime = int(timezone.now().strftime('%s'))\n return self._mtime","def find_file_modified_time(file):\n#\n#--- find stat of the file. one of them is the file creation date\n#\n (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(file)\n out = time.ctime(mtime)\n#\n#--- out is in \"Mon Dec 01 15:22:37 2014\" format\n#\n atemp = re.split('\\s+', out)\n \n month = changeMonthFormat(atemp[1])\n date = int(float(atemp[2]))\n year = int(float(atemp[4]))\n\n btemp = re.split(':', atemp[3])\n\n hours = int(float(btemp[0]))\n minutes = int(float(btemp[1]))\n seconds = int(float(btemp[2]))\n\n stime = convertDateToTime2(year, month, date, hours, minutes, seconds)\n \n return stime","def most_recent_file(folder):\n files = ErrorLog.get_files(folder)\n files_with_mod_dates = [[os.path.abspath(file),\n datetime.datetime.fromtimestamp(os.path.getmtime(file))] # modified date\n for file in files]\n if not files_with_mod_dates:\n return None, None\n most_recent_file = files_with_mod_dates[0][0]\n most_recent_file_date = files_with_mod_dates[0][1]\n for file, mod_date in files_with_mod_dates:\n if mod_date > most_recent_file_date:\n most_recent_file = file\n most_recent_file_date = mod_date\n return most_recent_file, most_recent_file_date","def get_created_time(self, name):\n full_path = self.path(name)\n return self.__volume.getctime(full_path)","def mtime(self):\r\n return self.info().mtime","def created_date_time(self):\n if \"createdDateTime\" in self._prop_dict:\n return datetime.strptime(self._prop_dict[\"createdDateTime\"].replace(\"Z\", \"\"), \"%Y-%m-%dT%H:%M:%S.%f\")\n else:\n return None","def get_mod_time(self):\n if self.file_meta[:2] == b'bp':\n file_meta_plist = ccl_bplist.load(BytesIO(self.file_meta))\n raw_date_time = file_meta_plist['$objects'][1]['LastModified']\n converted_time = datetime.datetime.fromtimestamp(raw_date_time)\n converted_time = converted_time.timetuple()\n return converted_time\n else:\n file_meta_plist = plistlib.loads(self.file_meta)\n return file_meta_plist['modified'].timetuple()","def LegacyCreationDate(self, default=None):\n return self.data.get('metadata', {}).get('legacy_creation_date', default)","def get_mtime(self):\n return os.path.getmtime(self.get_path())","def mtime(path):","def get_last_update(self):\n last_update = os.path.getmtime(self.parent_filepath)\n return last_update","def GetGsutilVersionModifiedTime():\n if not VERSION_FILE:\n return 0\n return int(os.path.getmtime(VERSION_FILE))","def check_file_creation(today_filename):\r\n\r\n if os.path.exists(today_filename):\r\n print(\"Today's file {} has been created\".format(today_filename))\r\n else:\r\n print(\"Today's file was not created\")","def mtime(self):\n\n return os.stat(self.filename).st_mtime","def creation_date(self) -> str:\n return pulumi.get(self, \"creation_date\")","def creation_date(self) -> str:\n return pulumi.get(self, \"creation_date\")","def creation_date(self) -> str:\n return pulumi.get(self, \"creation_date\")","def _get_date():\n return datetime.datetime.now()","def extract_date_metadata(fname):\n\n try:\n # check if file has creation date, exception if not\n date_metadata = fileops.get_video_creation_date_metadata(fname)\n\n # extract the date/time string from metadata, exception if\n # not the proper format\n datetimestr = metadata_to_datetimestr(date_metadata)\n\n logging.debug(\"Found creation date metadata %r for file %r\",\n datetimestr, os.path.basename(fname))\n\n return datetimestr\n\n except fileops.VideoMetadataError:\n logging.warning(\n \"%r does not have a proper creation date metadata\",\n os.path.basename(fname))\n\n return \"\"\n\n except DateStrError:\n logging.warning(\n \"%r creation data metadata not the right format\",\n os.path.basename(fname))\n \n return \"\"","def setLastModified(when):","def get_seviri_file_time(file):\n if hasattr(file, '__iter__'):\n filenames = [f.split('/')[-1] for f in file]\n date = [datetime(int(f[38:42]), int(f[42:44]),\n int(f[44:46]), int(f[46:48]),\n int(f[48:50])) for f in filenames]\n else:\n f = file.split('/')[-1]\n date = datetime(int(f[38:42]), int(f[42:44]),\n int(f[44:46]), int(f[46:48]),\n int(f[48:50]))\n return date","def timestamp_one(self, path):\n stat = path.stat()\n sde = self.manager.source_date_epoch\n if stat.st_mtime > sde:\n cls = self.__class__.__name__\n self.log.debug(\n f\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\"\n )\n os.utime(path, (sde, sde))\n return\n return","def timestamp_one(self, path):\n stat = path.stat()\n sde = self.manager.source_date_epoch\n if stat.st_mtime > sde:\n cls = self.__class__.__name__\n self.log.debug(\n f\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\"\n )\n os.utime(path, (sde, sde))\n return\n return"],"string":"[\n \"def _creation_date(path_to_file):\\n if platform.system() == \\\"Windows\\\":\\n return os.path.getctime(path_to_file)\\n else:\\n stat = os.stat(path_to_file)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n return stat.st_mtime\",\n \"def creation_date(path_to_file):\\n if platform.system() == 'Windows':\\n return os.path.getctime(path_to_file)\\n else:\\n stat = os.stat(path_to_file)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n return stat.st_mtime\",\n \"def creation_date(path_to_file):\\n if platform.system() == 'Windows':\\n print(\\\"last modified: %s\\\" % time.ctime(os.path.getmtime(path_to_file)))\\n modtime = time.ctime(os.path.getmtime(path_to_file))\\n \\n print(\\\"created: %s\\\" % time.ctime(os.path.getctime(path_to_file)))\\n modtime = datetime.datetime.strptime(modtime, \\\"%a %b %d %H:%M:%S %Y\\\")\\n modtime = datetime.datetime.strftime(modtime, \\\"%Y-%m-%d\\\")\\n return modtime\",\n \"def creation_date(path_to_file):\\n if platform.system() == 'Windows':\\n return os.path.getctime(path_to_file)\\n else:\\n stat = os.stat(path_to_file)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n return stat.st_mtime\",\n \"def creation_date(path_to_file):\\n if platform.system() == 'Windows':\\n return os.path.getctime(path_to_file)\\n else:\\n stat = os.stat(path_to_file)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n return stat.st_mtime\",\n \"def creation_date(file_path):\\n date = None\\n if platform.system() == 'Windows':\\n try:\\n date = os.path.getctime(file_path)\\n except FileNotFoundError:\\n print('FileNotFoundError: ' + file_path)\\n UTILITIES_LOGGER.error('FileNotFoundError: ' + file_path)\\n else:\\n try:\\n stat = os.stat(file_path)\\n try:\\n date = stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n date = stat.st_mtime\\n except FileNotFoundError as e:\\n print('FileNotFoundError: ' + file_path)\\n UTILITIES_LOGGER.exception('FileNotFoundError: ' + file_path)\\n # return datetime.datetime.fromtimestamp(int(date)).strftime('%Y-%m-%d %H:%M:%S')\\n # Got error: OverflowError: timestamp out of range for platform time_t\\n # When manually testing with existing files from Windows. Probably not an issue in real\\n # usage, but fixed anyway with datetime.datetime.utcfromtimestamp().\\n # See: https://stackoverflow.com/questions/3682748/converting-unix-timestamp-string-to-readable-date#comment30046351_3682808\\n try:\\n return datetime.datetime.utcfromtimestamp(int(date)).strftime('%Y-%m-%d %H:%M:%S')\\n except OverflowError as e:\\n # Getting OverflowError when testing with some files, not sure of root cause\\n # This perhaps is only a problem when the file is read on creation when copied to sesison directory.\\n # It gets read a second time when modified. Need to wait for the copy to finish?\\n print('OverflowError: date value: ' + str(date) + ' for file:' + file_path)\\n UTILITIES_LOGGER.exception('OverflowError: date:' + str(date) + ' file:' + file_path)\\n return None\",\n \"def creation_date(path_to_file, return_datetime=True):\\n if platform.system() == 'Windows':\\n created_at = os.path.getctime(path_to_file)\\n else:\\n stat = os.stat(path_to_file)\\n try:\\n created_at = stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n created_at = stat.st_mtime\\n\\n if return_datetime:\\n return datetime.fromtimestamp(created_at)\\n else:\\n return created_at\",\n \"def get_file_date(self, file: str) -> date:\",\n \"def file_creation_date(file_path):\\n # Must be a valid path string\\n assert os.path.isfile(file_path) is True\\n\\n unix_timestamp = os.path.getctime(file_path)\\n\\n return datetime.fromtimestamp(unix_timestamp)\",\n \"def creation_date(path):\\n if platform.system() == 'Windows':\\n return os.path.getctime(path)\\n else:\\n stat = os.stat(path)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n return stat.st_mtime\",\n \"def creation_date(filename):\\n try:\\n if filename.endswith(JPEG_EXTENSIONS):\\n timestamp = creation_date_from_exif(filename)\\n else:\\n timestamp = creation_date_from_hachoir(filename)\\n except ValueError:\\n timestamp = None\\n\\n try:\\n path_date = creation_date_from_path(filename)\\n except ValueError:\\n return timestamp\\n\\n if not timestamp:\\n return path_date\\n\\n # Preserve path timestamp if incompatible with image timestamp\\n if timestamp < path_date - timedelta(days=2):\\n return path_date\\n if timestamp > path_date + timedelta(days=1):\\n return path_date\\n\\n return timestamp\",\n \"def creation_date_from_path(filename):\\n try:\\n return _find_datetime(os.path.basename(filename))\\n except ValueError:\\n pass\\n\\n try:\\n return _find_date(os.path.basename(filename)[:10])\\n except ValueError:\\n pass\\n\\n try:\\n return _find_date(os.path.basename(filename))\\n except ValueError:\\n pass\\n\\n try:\\n return _find_date(os.path.dirname(filename))\\n except ValueError:\\n pass\\n\\n raise ValueError(f\\\"No date found in path for {filename}\\\")\",\n \"def getCreationDate(filename):\\r\\n path = cachePath(filename)\\r\\n \\r\\n pe = pefile.PE(path)\\r\\n return datetime.fromtimestamp(pe.FILE_HEADER.TimeDateStamp)\",\n \"def creation_date_video(path_to_file):\\n print(\\\"Last modified: %s\\\" % time.ctime(os.path.getmtime(path_to_file)))\\n print(\\\"Created: %s\\\" % time.ctime(os.path.getctime(path_to_file)))\\n # return os.path.getctime(path_to_file)\",\n \"def findcreatedate(self):\\n try:\\n exifdata = subprocess.check_output(['exiftool', '-j', '-TAG', '-CreateDate', self.filename])\\n except OSError as e:\\n print \\\"exiftool may not be installed. Please go check.\\\"\\n print \\\"Here is the error thrown: {}\\\".format(e)\\n raise\\n\\n data = json.loads(exifdata)\\n self.createdate = date(*[int(elt) for elt in re.split('[ :]', data[0]['CreateDate'])][0:3])\\n return self.createdate\",\n \"def created(self) -> datetime.datetime:\\n # REMARK: On Unix systems getctime() returns the time of most recent\\n # metadata change, but not the creation.\\n # https://stackoverflow.com/questions/237079/how-do-i-get-file-creation-and-modification-date-times\\n # https://docs.python.org/3/library/os.html#os.stat_result\\n if platform.system() == \\\"Windows\\\":\\n timestamp = os.path.getctime(self._manifest_path)\\n\\n else:\\n stat = os.stat(self._manifest_path)\\n try:\\n timestamp = stat.st_birthtime\\n except AttributeError:\\n timestamp = stat.st_mtime\\n\\n return datetime.datetime.fromtimestamp(timestamp)\",\n \"def get_file_modification_date() -> str:\\n file_modification_date = datetime.now().strftime(\\\"%d.%m.%Y\\\")\\n print(file_modification_date)\\n return file_modification_date\",\n \"def get_file_modified_date(filepath):\\n return datetime.datetime.fromtimestamp(os.path.getmtime(filepath))\",\n \"def _get_date_modified(path):\\n return str(datetime.datetime.fromtimestamp(os.path.getmtime(path)))\",\n \"def get_file_cm_time(file_path):\\n try:\\n create_time = os.path.getctime(file_path)\\n if create_time:\\n return int(create_time)\\n modify_time = os.path.getmtime(file_path)\\n if modify_time:\\n return int(modify_time)\\n except (OSError, ValueError) as e:\\n logger.error('Error while get creation time of file. ERROR: %s.',\\n str(e))\\n return 0\",\n \"def get_file_age_default(path, cur_parsed, cur_datetime):\\n\\tmtime = datetime.fromtimestamp(os.path.getmtime(path))\\n\\tmtime = str(mtime).split(' ')[0]\\n\\tmtime = parse_date_str(mtime, '-', 0, 1, 2)\\n\\tprint(\\\"file mtime: {}\\\".format(mtime))\\n\\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], mtime[0], mtime[1], mtime[2])\\n\\treturn date_dif\",\n \"def creation_year(path_to_file):\\n if platform.system() == 'Windows':\\n print(\\\"last modified: %s\\\" % time.ctime(os.path.getmtime(path_to_file)))\\n modtime = time.ctime(os.path.getmtime(path_to_file))\\n \\n print(\\\"created: %s\\\" % time.ctime(os.path.getctime(path_to_file)))\\n modtime = datetime.datetime.strptime(modtime, \\\"%a %b %d %H:%M:%S %Y\\\")\\n modtime = datetime.datetime.strftime(modtime, \\\"%Y\\\")\\n return modtime\",\n \"def get_file_modification_time(self, filename):\\n mtime = None\\n if os.path.exists(filename):\\n mtime = datetime.datetime.fromtimestamp(os.path.getmtime(filename))\\n return mtime\",\n \"def try_utime(self, filename, last_modified_hdr):\\n if last_modified_hdr is None:\\n return\\n if not os.path.isfile(encodeFilename(filename)):\\n return\\n timestr = last_modified_hdr\\n if timestr is None:\\n return\\n filetime = timeconvert(timestr)\\n if filetime is None:\\n return filetime\\n # Ignore obviously invalid dates\\n if filetime == 0:\\n return\\n with contextlib.suppress(Exception):\\n os.utime(filename, (time.time(), filetime))\\n return filetime\",\n \"def get_file_last_modification_date(filename=None):\\n with open(filename, 'r') as fp:\\n for line in fp:\\n if line.startswith('Modify'):\\n date_line = line.split()[1]\\n file_date = datetime.strptime(date_line, \\\"%Y-%m-%d\\\")\\n return filename, file_date\",\n \"def creation_month(path_to_file):\\n if platform.system() == 'Windows':\\n print(\\\"last modified: %s\\\" % time.ctime(os.path.getmtime(path_to_file)))\\n modtime = time.ctime(os.path.getmtime(path_to_file))\\n \\n print(\\\"created: %s\\\" % time.ctime(os.path.getctime(path_to_file)))\\n modtime = datetime.datetime.strptime(modtime, \\\"%a %b %d %H:%M:%S %Y\\\")\\n modtime = datetime.datetime.strftime(modtime, \\\"%B\\\")\\n return modtime\",\n \"def getDate(path):\\n utime = ftp.stat(path=path).st_mtime\\n last_modified = datetime.fromtimestamp(utime)\\n return last_modified\",\n \"def get_mtime(self):\\n if not os.path.exists(self.file_name):\\n return None\\n st = os.stat(self.file_name)\\n return st.st_mtime\",\n \"def last_modified(self):\\n return os.path.getmtime(self.filename)\",\n \"def get_last_usage_date(path: str) -> datetime:\\r\\n date: datetime\\r\\n\\r\\n if not os.path.exists(path):\\r\\n raise FileNotFoundError(\\\"Path does not exist: \\\" + path)\\r\\n\\r\\n try:\\r\\n date = datetime.fromtimestamp(os.path.getmtime(path))\\r\\n except Exception:\\r\\n pass\\r\\n\\r\\n try:\\r\\n compare_date = datetime.fromtimestamp(os.path.getatime(path))\\r\\n if date.date() < compare_date.date():\\r\\n # compare date is newer\\r\\n date = compare_date\\r\\n except Exception:\\r\\n pass\\r\\n\\r\\n try:\\r\\n compare_date = datetime.fromtimestamp(os.path.getctime(path))\\r\\n if date.date() < compare_date.date():\\r\\n # compare date is newer\\r\\n date = compare_date\\r\\n except Exception:\\r\\n pass\\r\\n\\r\\n return date\",\n \"def DateCreated(filepath, stringformat=False):\\n time_in_s = os.path.getctime(filepath)\\n if stringformat:\\n return time.ctime(time_in_s)\\n else:\\n return time_in_s\",\n \"def get_timestamp(file_path):\\n mtime = os.stat(file_path).st_mtime\\n return datetime.datetime.fromtimestamp(mtime).isoformat()\",\n \"def creation_date_from_hachoir(filename):\\n parser = createParser(filename)\\n metadata = extractMetadata(parser)\\n if metadata is None:\\n raise ValueError(f\\\"Hachoir found no metadata for {filename}\\\")\\n return metadata.get(\\\"creation_date\\\")\",\n \"def creation_date_tuple(file_path):\\n return file_path, creation_date(file_path)\",\n \"def testCreationTime(self):\\n path_spec = path_spec_factory.Factory.NewPathSpec(\\n definitions.TYPE_INDICATOR_HFS,\\n identifier=self._IDENTIFIER_ANOTHER_FILE,\\n location='/a_directory/another_file',\\n parent=self._raw_path_spec)\\n file_entry = self._file_system.GetFileEntryByPathSpec(path_spec)\\n\\n self.assertIsNotNone(file_entry)\\n self.assertIsNotNone(file_entry.creation_time)\",\n \"def get_last_modified_date(self):\\n\\t\\treturn call_sdk_function('PrlFsEntry_GetLastModifiedDate', self.handle)\",\n \"def getmtime(self):\\n if self.exists():\\n return os.path.getmtime(self.path)\\n return 0\",\n \"def checkDateForFileName(self):\\n #self.currentLocalTime was already changed in log Temperatures\\n if self.currentLocalTime.tm_mday != self.currentDay:\\n #the day has changed we should start a new log file!\\n self.logFile = self._logFile_default()\\n self._create_log_file()\",\n \"def last_modified(path):\\n\\n date = os.path.getmtime(path)\\n date = datetime.datetime.fromtimestamp(date)\\n return time.mktime(date.timetuple())\",\n \"def get_modified_time(fname):\\n return os.stat(fname).st_mtime\",\n \"def last_modified():\\n return \\\"Last modified: %s\\\" % time.ctime(os.path.getmtime(FILE_NAME))\",\n \"def modified(self) -> datetime:\\n # TODO: Should this be overridden for LocalDirectoryAsset?\\n return datetime.fromtimestamp(self.filepath.stat().st_mtime).astimezone()\",\n \"def get_creation_time(self):\\n return self.get_attr('date_created')\",\n \"def last_modified_date_time(self):\\n if \\\"lastModifiedDateTime\\\" in self._prop_dict:\\n return datetime.strptime(self._prop_dict[\\\"lastModifiedDateTime\\\"].replace(\\\"Z\\\", \\\"\\\"), \\\"%Y-%m-%dT%H:%M:%S.%f\\\")\\n else:\\n return None\",\n \"def get_creation_time(ts):\\n path_to_embed_file = os.path.join(DATA_DIR, STUDY, \\\"experiment_files\\\", \\\"experiment_\\\"+ ts, \\\"triplet_training_validation_embeddings.h5\\\")\\n\\n if os.path.exists(path_to_embed_file):\\n stat = os.stat(path_to_embed_file)\\n try:\\n return stat.st_birthtime\\n except AttributeError:\\n # We're probably on Linux. No easy way to get creation dates here,\\n # so we'll settle for when its content was last modified.\\n return stat.st_mtime\\n else:\\n print (\\\"here, path is: \\\", path_to_embed_file)\\n return None\",\n \"def DateModified(filepath, stringformat=False):\\n time_in_s = os.path.getmtime(filepath)\\n if stringformat:\\n return time.ctime(time_in_s)\\n else:\\n return time_in_s\",\n \"def DateCreated(self, default=None):\\n return self.data.get('metadata', {}).get('_created', default)\",\n \"def getFileModifTime(filename):\\n\\tfilename = adaptPath(filename)\\n\\tfrom os import stat\\n\\ttry:\\n\\t\\tresult = stat(filename).st_mtime\\n\\texcept:\\n\\t\\tresult = 0\\n\\treturn result\",\n \"def stat_timestamp(filename):\\n return os.stat(filename).st_mtime\",\n \"def _GetUpdateTime(filename):\\n stat_info = os.stat(filename)\\n return (stat_info.st_atime, stat_info.st_mtime)\",\n \"def get_file_last_update_time(fname):\\n\\n try:\\n lastupdate = datetime.fromtimestamp(os.stat(fname).st_mtime)\\n except Exception:\\n lastupdate = None\\n\\n return lastupdate\",\n \"def timestamp(self):\\n\\t\\tcurrent_stamp = 0\\n\\t\\tcurrent_size = 0\\n\\t\\ttry:\\n\\t\\t\\tst = stat(self._file)\\n\\t\\t\\tif st:\\n\\t\\t\\t\\tcurrent_stamp = int(st.st_mtime)\\n\\t\\t\\t\\tcurrent_size = st.st_size\\n\\t\\t\\t\\t# Fake a changed mtime if size is different. Subsequent processing\\n\\t\\t\\t\\t# only depends on the mtime field.\\n\\t\\t\\t\\tif current_size != self._last_size:\\n\\t\\t\\t\\t\\tcurrent_stamp = int(time())\\n\\t\\t\\t\\t\\tMODULE.info(\\\"Size of '%s': %s -> %s\\\" % (self._file,self._last_size,current_size))\\n\\t\\t\\t\\t\\tself._last_size = current_size\\n\\t\\tfinally:\\n\\t\\t\\tpass\\n\\n\\t\\tif current_stamp == self._last_stamp:\\n\\t\\t\\tself._unchanged_count += 1\\n\\t\\t\\tif self._unchanged_count >= self._count:\\n\\t\\t\\t\\t# Don't record new timestamp if MD5 of file is the same\\n\\t\\t\\t\\thash = md5(open(self._file).read()).hexdigest()\\n\\t\\t\\t\\tif hash != self._last_md5:\\n\\t\\t\\t\\t\\tself._last_md5 = hash\\n\\t\\t\\t\\t\\tself._last_returned_stamp = current_stamp\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tMODULE.info(\\\"Hash of '%s' unchanged\\\" % self._file)\\n\\t\\telse:\\n\\t\\t\\tself._unchanged_count = 0\\n\\t\\t\\tself._last_stamp = current_stamp\\n\\n\\t\\treturn self._last_returned_stamp\",\n \"def get_creation_time(self):\\n return self.creation_time\",\n \"def file_creation_date(file_path):\\n ran_command = run_command([\\\"stat\\\", \\\"-f\\\", \\\"%SB\\\", file_path], True)\\n raw_command_output = get_subprocess_output(ran_command)\\n command_output = raw_command_output.strip(\\\"\\\\\\\\n\\\")\\n elements = command_output.split(\\\" \\\")\\n month_string = elements[0]\\n month_number = 0\\n day_number = int(elements[1])\\n year_number = int(elements[3])\\n if month_string == \\\"January\\\":\\n month_number += 1\\n elif month_string == \\\"February\\\":\\n month_number += 2\\n elif month_string == \\\"March\\\":\\n month_number += 3\\n elif month_string == \\\"April\\\":\\n month_number += 4\\n elif month_string == \\\"May\\\":\\n month_number += 5\\n elif month_string == \\\"June\\\":\\n month_number += 6\\n elif month_string == \\\"July\\\":\\n month_number += 7\\n elif month_string == \\\"August\\\":\\n month_number += 8\\n elif month_string == \\\"September\\\":\\n month_number += 9\\n elif month_string == \\\"October\\\":\\n month_number += 10\\n elif month_string == \\\"November\\\":\\n month_number += 11\\n elif month_string == \\\"December\\\":\\n month_number += 12\\n return [month_number, day_number, year_number]\",\n \"def __get_modification_time(filename: str) -> float:\\n return os.stat(filename).st_mtime\",\n \"def modified(filename: str) -> datetime.datetime:\\n fs, relative_path = url_to_fs(filename)\\n return cast(datetime.datetime, fs.modified(relative_path))\",\n \"def get_file_age_win(path, cur_parsed, cur_datetime):\\n\\ttry:\\n\\t\\tdate_str = time.ctime(os.path.getctime(path))\\n\\t\\tdate_parsed = parse_date_str(date_str, ' ', 4, 1, 2)\\n\\t\\tprint(\\\"file crtime: {}\\\".format(date_parsed))\\n\\t\\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], date_parsed[0], date_parsed[1], date_parsed[2])\\n\\t\\treturn date_dif\\n\\texcept:\\n\\t\\tprint(\\\"EXCEPTION! fallback to mtime!\\\")\\n\\t\\treturn get_file_age_default(path, cur_parsed, cur_datetime)\",\n \"def last_new_file_time(self) -> datetime.datetime:\\n with self.lock:\\n return self._last_new_file_time\",\n \"def _get_file_mtime(self, sentry_unit, filename):\\n return sentry_unit.file_stat(filename)['mtime']\",\n \"def last_updated(self) -> Optional[datetime]:\\n try:\\n with open(self.last_updated_file) as f:\\n dt = datetime.fromisoformat(f.read())\\n if dt.tzinfo is None:\\n dt = dt.astimezone(timezone.utc)\\n return dt\\n except FileNotFoundError:\\n return None\",\n \"def _get_date_taken(path):\\n return Image.open(path)._getexif()[36867]\",\n \"def get_mtime(self):\\n storage = getattr(self._file, \\\"storage\\\", None)\\n if storage:\\n return storage.modified_time(self._file.name)\\n return super(FileAsset, self).get_mtime()\",\n \"def last_update(cls):\\n\\n import datetime, os\\n from s3 import S3DateTime\\n\\n # Probe file (probing one is good enough since update_data\\n # writes them all at the same time)\\n filename = os.path.join(current.request.folder,\\n \\\"static\\\", \\\"themes\\\", \\\"SHARE\\\", \\\"data\\\",\\n \\\"people_affected.json\\\",\\n )\\n try:\\n mtime = os.path.getmtime(filename)\\n except OSError:\\n last_update = None\\n else:\\n dt = datetime.datetime.utcfromtimestamp(mtime)\\n last_update = S3DateTime.datetime_represent(dt, utc=True)\\n\\n return last_update\",\n \"def last_update(cls):\\n\\n import datetime, os\\n from s3 import S3DateTime\\n\\n # Probe file (probing one is good enough since update_data\\n # writes them all at the same time)\\n filename = os.path.join(current.request.folder,\\n \\\"static\\\", \\\"themes\\\", \\\"SHARE\\\", \\\"data\\\",\\n \\\"people_affected.json\\\",\\n )\\n try:\\n mtime = os.path.getmtime(filename)\\n except OSError:\\n last_update = None\\n else:\\n dt = datetime.datetime.utcfromtimestamp(mtime)\\n last_update = S3DateTime.datetime_represent(dt, utc=True)\\n\\n return last_update\",\n \"def _get_object_mtime(self, obj):\\n try:\\n mtime = os.path.getmtime(inspect.getsourcefile(obj.__class__))\\n except (TypeError, OSError):\\n mtime = 0.\\n return mtime\",\n \"def getCreationTime(self): #$NON-NLS-1$\\r\",\n \"def creation_date_time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"creation_date_time\\\")\",\n \"def creation_date_from_exif(filename):\\n # Source: https://orthallelous.wordpress.com/2015/04/19/extracting-date-and-time-from-images-with-python/\\n with Image.open(filename) as img:\\n exif = img.getexif()\\n\\n if exif is None:\\n raise ValueError(f\\\"No exif data for {filename}\\\")\\n\\n # for subsecond prec, see doi.org/10.3189/2013JoG12J126 , sect. 2.2, 2.3\\n tags = [\\n (36867, 37521), # (DateTimeOriginal, SubsecTimeOriginal)\\n (36868, 37522), # (DateTimeDigitized, SubsecTimeDigitized)\\n (306, 37520), # (DateTime, SubsecTime)\\n ]\\n\\n for tag in tags:\\n dat = exif.get(tag[0])\\n sub = exif.get(tag[1], 0)\\n\\n # PIL.PILLOW_VERSION >= 3.0 returns a tuple\\n dat = dat[0] if isinstance(dat, tuple) else dat\\n if not dat:\\n continue\\n\\n sub = sub[0] if isinstance(sub, tuple) else sub\\n if isinstance(sub, int):\\n sub = f\\\"{sub:06d}\\\"\\n\\n date, time = dat.split(\\\" \\\")\\n date = date.replace(\\\":\\\", \\\"-\\\")\\n return fromisoformat(f\\\"{date}T{time}.{sub}\\\")\\n\\n raise ValueError(f\\\"No date found in the exif data for {filename}\\\")\",\n \"def out_of_date(original, derived):\\r\\n return (not os.path.exists(derived) or\\r\\n (os.path.exists(original) and\\r\\n os.stat(derived).st_mtime < os.stat(original).st_mtime))\",\n \"def last_modified_date(*paths, **kwargs):\\n return check_output([\\n 'git',\\n 'log',\\n '-n', '1',\\n '--pretty=format:%cd',\\n '--date=iso',\\n '--',\\n *paths\\n ], **kwargs).decode('utf-8')\",\n \"def getLastModifiedTime(self): #$NON-NLS-1$\\r\",\n \"def last_access_time(path):\\r\\n return os.stat(path)[stat.ST_ATIME]\",\n \"def file_get_mdatetime(filename):\\n return datetime.datetime.utcfromtimestamp(os.path.getmtime(filename))\",\n \"def last_date_method(self) -> datetime.datetime:\\n\\n try:\\n with open(os.path.join(THIS_DIR, \\\"data_file.json\\\"), mode='r') as json_file:\\n try:\\n data = datetime.datetime.strptime(json.load(json_file)[self.site],\\n '%Y-%m-%d %H:%M:%S')\\n return data\\n\\n except:\\n return datetime.datetime(1970, 1, 1)\\n except:\\n with open(os.path.join(THIS_DIR, \\\"data_file.json\\\"), mode='a') as json_file:\\n json.dump({}, json_file)\\n json_file.close()\\n\\n return datetime.datetime(1970, 1, 1)\",\n \"def getmodtime(filename, default=None):\\n if os.path.exists(filename):\\n return os.stat(filename)[os.path.stat.ST_MTIME]\\n else:\\n return default\",\n \"def creationTime(self):\\n \\n if not self.logMessage is None :\\n return self.logMessage[\\\"date\\\"]\",\n \"def check(self, name, entry):\\n\\n f = file(name, self.mode)\\n fs = fstat(f.fileno())\\n ts1 = fs[-2]\\n try:\\n ts2 = entry._timestamp\\n except AttributeError:\\n ts2 = ts1-1\\n\\n if ts2<ts1:\\n entry._timestamp=ts1\\n return f\\n else:\\n return None\",\n \"def mtime(self):\\n if self.source_file is None:\\n return None\\n if self._mtime is None:\\n try:\\n try: # Locally stored file\\n mtime = os.path.getmtime(self.source_file.path)\\n self._mtime = int(mtime)\\n except NotImplementedError: # AWS S3 storage\\n key = self.source_file.file.key\\n modified = boto.utils.parse_ts(key.last_modified)\\n self._mtime = int(modified.strftime('%s'))\\n except (FileNotFoundError, AttributeError):\\n self._mtime = int(timezone.now().strftime('%s'))\\n return self._mtime\",\n \"def find_file_modified_time(file):\\n#\\n#--- find stat of the file. one of them is the file creation date\\n#\\n (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(file)\\n out = time.ctime(mtime)\\n#\\n#--- out is in \\\"Mon Dec 01 15:22:37 2014\\\" format\\n#\\n atemp = re.split('\\\\s+', out)\\n \\n month = changeMonthFormat(atemp[1])\\n date = int(float(atemp[2]))\\n year = int(float(atemp[4]))\\n\\n btemp = re.split(':', atemp[3])\\n\\n hours = int(float(btemp[0]))\\n minutes = int(float(btemp[1]))\\n seconds = int(float(btemp[2]))\\n\\n stime = convertDateToTime2(year, month, date, hours, minutes, seconds)\\n \\n return stime\",\n \"def most_recent_file(folder):\\n files = ErrorLog.get_files(folder)\\n files_with_mod_dates = [[os.path.abspath(file),\\n datetime.datetime.fromtimestamp(os.path.getmtime(file))] # modified date\\n for file in files]\\n if not files_with_mod_dates:\\n return None, None\\n most_recent_file = files_with_mod_dates[0][0]\\n most_recent_file_date = files_with_mod_dates[0][1]\\n for file, mod_date in files_with_mod_dates:\\n if mod_date > most_recent_file_date:\\n most_recent_file = file\\n most_recent_file_date = mod_date\\n return most_recent_file, most_recent_file_date\",\n \"def get_created_time(self, name):\\n full_path = self.path(name)\\n return self.__volume.getctime(full_path)\",\n \"def mtime(self):\\r\\n return self.info().mtime\",\n \"def created_date_time(self):\\n if \\\"createdDateTime\\\" in self._prop_dict:\\n return datetime.strptime(self._prop_dict[\\\"createdDateTime\\\"].replace(\\\"Z\\\", \\\"\\\"), \\\"%Y-%m-%dT%H:%M:%S.%f\\\")\\n else:\\n return None\",\n \"def get_mod_time(self):\\n if self.file_meta[:2] == b'bp':\\n file_meta_plist = ccl_bplist.load(BytesIO(self.file_meta))\\n raw_date_time = file_meta_plist['$objects'][1]['LastModified']\\n converted_time = datetime.datetime.fromtimestamp(raw_date_time)\\n converted_time = converted_time.timetuple()\\n return converted_time\\n else:\\n file_meta_plist = plistlib.loads(self.file_meta)\\n return file_meta_plist['modified'].timetuple()\",\n \"def LegacyCreationDate(self, default=None):\\n return self.data.get('metadata', {}).get('legacy_creation_date', default)\",\n \"def get_mtime(self):\\n return os.path.getmtime(self.get_path())\",\n \"def mtime(path):\",\n \"def get_last_update(self):\\n last_update = os.path.getmtime(self.parent_filepath)\\n return last_update\",\n \"def GetGsutilVersionModifiedTime():\\n if not VERSION_FILE:\\n return 0\\n return int(os.path.getmtime(VERSION_FILE))\",\n \"def check_file_creation(today_filename):\\r\\n\\r\\n if os.path.exists(today_filename):\\r\\n print(\\\"Today's file {} has been created\\\".format(today_filename))\\r\\n else:\\r\\n print(\\\"Today's file was not created\\\")\",\n \"def mtime(self):\\n\\n return os.stat(self.filename).st_mtime\",\n \"def creation_date(self) -> str:\\n return pulumi.get(self, \\\"creation_date\\\")\",\n \"def creation_date(self) -> str:\\n return pulumi.get(self, \\\"creation_date\\\")\",\n \"def creation_date(self) -> str:\\n return pulumi.get(self, \\\"creation_date\\\")\",\n \"def _get_date():\\n return datetime.datetime.now()\",\n \"def extract_date_metadata(fname):\\n\\n try:\\n # check if file has creation date, exception if not\\n date_metadata = fileops.get_video_creation_date_metadata(fname)\\n\\n # extract the date/time string from metadata, exception if\\n # not the proper format\\n datetimestr = metadata_to_datetimestr(date_metadata)\\n\\n logging.debug(\\\"Found creation date metadata %r for file %r\\\",\\n datetimestr, os.path.basename(fname))\\n\\n return datetimestr\\n\\n except fileops.VideoMetadataError:\\n logging.warning(\\n \\\"%r does not have a proper creation date metadata\\\",\\n os.path.basename(fname))\\n\\n return \\\"\\\"\\n\\n except DateStrError:\\n logging.warning(\\n \\\"%r creation data metadata not the right format\\\",\\n os.path.basename(fname))\\n \\n return \\\"\\\"\",\n \"def setLastModified(when):\",\n \"def get_seviri_file_time(file):\\n if hasattr(file, '__iter__'):\\n filenames = [f.split('/')[-1] for f in file]\\n date = [datetime(int(f[38:42]), int(f[42:44]),\\n int(f[44:46]), int(f[46:48]),\\n int(f[48:50])) for f in filenames]\\n else:\\n f = file.split('/')[-1]\\n date = datetime(int(f[38:42]), int(f[42:44]),\\n int(f[44:46]), int(f[46:48]),\\n int(f[48:50]))\\n return date\",\n \"def timestamp_one(self, path):\\n stat = path.stat()\\n sde = self.manager.source_date_epoch\\n if stat.st_mtime > sde:\\n cls = self.__class__.__name__\\n self.log.debug(\\n f\\\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\\\"\\n )\\n os.utime(path, (sde, sde))\\n return\\n return\",\n \"def timestamp_one(self, path):\\n stat = path.stat()\\n sde = self.manager.source_date_epoch\\n if stat.st_mtime > sde:\\n cls = self.__class__.__name__\\n self.log.debug(\\n f\\\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\\\"\\n )\\n os.utime(path, (sde, sde))\\n return\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8190197","0.805753","0.8000129","0.7986132","0.7986132","0.7926146","0.76267004","0.7622058","0.7512643","0.7511644","0.744479","0.7173829","0.7128207","0.696563","0.6958586","0.69365454","0.6904673","0.68706644","0.67324805","0.66605735","0.66230446","0.6622403","0.66029173","0.6595992","0.6567886","0.6564534","0.65588355","0.6558706","0.65433955","0.65408695","0.65311503","0.64908206","0.648316","0.6473861","0.6463879","0.6457813","0.64491606","0.644161","0.64357615","0.6413413","0.6395453","0.63879824","0.6382948","0.6380333","0.6358486","0.63577783","0.6348484","0.634826","0.6339991","0.6337986","0.63053715","0.6296621","0.6287273","0.6277261","0.6264758","0.6256424","0.62499744","0.6232914","0.61763126","0.61662096","0.61608005","0.6152107","0.6151655","0.6151655","0.6146978","0.614113","0.61261314","0.6117252","0.6111474","0.6086761","0.6084758","0.6077978","0.60774076","0.6071862","0.6063167","0.60616094","0.6059545","0.6056762","0.6050968","0.60471153","0.60432804","0.603216","0.6031549","0.60249275","0.6009007","0.5999472","0.5999163","0.598487","0.5984661","0.59757984","0.59674597","0.5959542","0.5959542","0.5959542","0.59576124","0.5940397","0.59090555","0.5901155","0.5896049","0.5896049"],"string":"[\n \"0.8190197\",\n \"0.805753\",\n \"0.8000129\",\n \"0.7986132\",\n \"0.7986132\",\n \"0.7926146\",\n \"0.76267004\",\n \"0.7622058\",\n \"0.7512643\",\n \"0.7511644\",\n \"0.744479\",\n \"0.7173829\",\n \"0.7128207\",\n \"0.696563\",\n \"0.6958586\",\n \"0.69365454\",\n \"0.6904673\",\n \"0.68706644\",\n \"0.67324805\",\n \"0.66605735\",\n \"0.66230446\",\n \"0.6622403\",\n \"0.66029173\",\n \"0.6595992\",\n \"0.6567886\",\n \"0.6564534\",\n \"0.65588355\",\n \"0.6558706\",\n \"0.65433955\",\n \"0.65408695\",\n \"0.65311503\",\n \"0.64908206\",\n \"0.648316\",\n \"0.6473861\",\n \"0.6463879\",\n \"0.6457813\",\n \"0.64491606\",\n \"0.644161\",\n \"0.64357615\",\n \"0.6413413\",\n \"0.6395453\",\n \"0.63879824\",\n \"0.6382948\",\n \"0.6380333\",\n \"0.6358486\",\n \"0.63577783\",\n \"0.6348484\",\n \"0.634826\",\n \"0.6339991\",\n \"0.6337986\",\n \"0.63053715\",\n \"0.6296621\",\n \"0.6287273\",\n \"0.6277261\",\n \"0.6264758\",\n \"0.6256424\",\n \"0.62499744\",\n \"0.6232914\",\n \"0.61763126\",\n \"0.61662096\",\n \"0.61608005\",\n \"0.6152107\",\n \"0.6151655\",\n \"0.6151655\",\n \"0.6146978\",\n \"0.614113\",\n \"0.61261314\",\n \"0.6117252\",\n \"0.6111474\",\n \"0.6086761\",\n \"0.6084758\",\n \"0.6077978\",\n \"0.60774076\",\n \"0.6071862\",\n \"0.6063167\",\n \"0.60616094\",\n \"0.6059545\",\n \"0.6056762\",\n \"0.6050968\",\n \"0.60471153\",\n \"0.60432804\",\n \"0.603216\",\n \"0.6031549\",\n \"0.60249275\",\n \"0.6009007\",\n \"0.5999472\",\n \"0.5999163\",\n \"0.598487\",\n \"0.5984661\",\n \"0.59757984\",\n \"0.59674597\",\n \"0.5959542\",\n \"0.5959542\",\n \"0.5959542\",\n \"0.59576124\",\n \"0.5940397\",\n \"0.59090555\",\n \"0.5901155\",\n \"0.5896049\",\n \"0.5896049\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79197496"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":23499,"cells":{"query":{"kind":"string","value":"Detect object classes in an image using precomputed object proposals."},"document":{"kind":"string","value":"def detect(self, image):\n\n # Load the demo image\n # Detect all object classes and regress object bounds\n image = image_transform_1_3(image)\n timer = Timer()\n timer.tic()\n scores, boxes = self.im_detect(image)\n timer.toc()\n print('rois--------------', scores)\n print ('Detection took {:.3f}s for '\n '{:d} object proposals'.format(timer.total_time, len(boxes)))\n\n CONF_THRESH = 0.3\n # print(scores)\n NMS_THRESH = 0.5\n dets = []\n for i in range(len(boxes)):\n # print('lll')\n cls_boxes = boxes[i]\n cls_scores = scores[i]\n dets_i_ = np.hstack([cls_boxes[:, 0:4], cls_scores])\n keep = nms(dets_i_, NMS_THRESH)\n dets_i = np.hstack([cls_boxes, cls_scores])\n dets_i = dets_i[keep, :]\n inds = np.where(dets_i[:, -1] >= CONF_THRESH)[0]\n dets_i = dets_i[inds, :]\n dets_i = dets_i[:, 0:5]\n dets.append(dets_i)\n return dets"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def detect_objects(interpreter, image):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n count = int(get_output_tensor(interpreter, 3))\n\n results = []\n for i in range(count):\n # Only check for people that meet the threshold\n if classes[i] == 0.0 and scores[i] >= THRESHOLD:\n result = {\n \"bounding_box\": boxes[i],\n \"class_id\": classes[i],\n \"score\": scores[i],\n }\n results.append(result)\n return results","def detect_objects(image, threshold, classes_incl=None):\n set_input_tensor(image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(0)\n classes = get_output_tensor(1)\n scores = get_output_tensor(2)\n count = int(get_output_tensor(3))\n\n results = []\n for i in range(count):\n if scores[i] >= threshold:\n result = {\n 'bounding_box': boxes[i],\n 'class_id': int(classes[i]),\n 'score': scores[i]\n }\n if not classes_incl:\n results.append(result)\n elif classes[i] in classes_incl:\n results.append(result)\n return results","def detect_objects(interpreter, image):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n #boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n #count = int(get_output_tensor(interpreter, 3))\n\n #results = []\n #for i in range(count):\n # if scores[i] >= threshold:\n # result = {\n # #'bounding_box': boxes[i],\n # 'class_id': classes[i],\n # 'score': scores[i]\n # }\n # results.append(result)\n \n \n #print(\"detection results:\\n\" + str(results))\n #return results\n return np.array([int(_class) for _class in classes]), np.array(scores)","def detect_objects(self, image):\n preprocessed_image = self._preprocess_image(image)\n\n # Feed the input image to the model\n self._set_input_tensor(preprocessed_image)\n self._interpreter.invoke()\n\n # Get all outputs from the model\n boxes = self._get_output_tensor(0)\n classes = self._get_output_tensor(1)\n scores = self._get_output_tensor(2)\n count = int(self._get_output_tensor(3))\n\n results = []\n for i in range(count):\n if scores[i] >= self.THRESHOLD:\n result = {\n 'bounding_box': boxes[i],\n 'class_id': classes[i],\n 'score': scores[i]\n }\n results.append(result)\n return results","def detect_objects(self, image):\n # Feed the input image to the model\n self.set_input_tensor(image)\n self.model.invoke()\n\n # Get all outputs from the model\n boxes = self.get_output_tensor(0)\n classes = self.get_output_tensor(1)\n scores = self.get_output_tensor(2)\n count = int(self.get_output_tensor(3))\n\n results = []\n for i in range(count):\n result = {\n 'bounding_box': boxes[i],\n 'class_id': int(classes[i]),\n 'score': scores[i]\n }\n results.append(result)\n return results","def detect_class_onpic(boxes, allowed_classes):\n object_class = \"all\"\n highest_prob = 0\n for box in boxes:\n box_prob = float(box[1].strip('%')) / 100.0\n if box[0] in allowed_classes and box_prob > highest_prob:\n highest_prob = box_prob\n object_class = box[0]\n return object_class, highest_prob","def detect_objects(self, image, threshold):\n self.set_input_tensor(image)\n self.interpreter.invoke()\n\n # Get all output details\n boxes = self.get_output_tensor(0)\n classes = self.get_output_tensor(1)\n scores = self.get_output_tensor(2)\n count = int(self.get_output_tensor(3))\n\n results = []\n for i in range(count):\n if scores[i] >= threshold:\n result = {\n 'bounding_box': boxes[i],\n 'class_id': classes[i],\n 'score': scores[i]\n }\n results.append(result)\n return results","def detect_image_objects(gray, detect_params, detect_type=\"all\", label=-1, verbose=False):\n if detect_type == \"all\":\n detected_rects = detect_all_objects(gray, verbose=verbose, **detect_params)\n elif detect_type == \"primary\":\n detected_rects = detect_primary_objects(gray, verbose=verbose, **detect_params)\n else:\n print(f\"Unrecongized input value for detect_type, {detect_type}, so no objects were detected!\")\n print(\"Please provide a string value for detect_type of either 1) 'all' or 2) 'primary'\")\n detected_rects = None\n if isinstance(detected_rects, np.ndarray):\n features_labels = get_detected_features_labels(gray, detected_rects, label=label, verbose=verbose)\n return features_labels","def demo(net, image_name,num_class,save_ff):\r\n\r\n # Load the demo image\r\n #im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\r\n im_file=image_name\r\n im = cv2.imread(im_file)\r\n\r\n # Detect all object classes and regress object bounds\r\n timer = Timer()\r\n timer.tic()\r\n #for zzz in range(100):\r\n scores, boxes = im_detect(net, im)\r\n timer.toc()\r\n print ('Detection took {:.3f}s for '\r\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\r\n\r\n # Visualize detections for each class\r\n CONF_THRESH = 0.35\r\n NMS_THRESH = 0.3\r\n thresh=CONF_THRESH\r\n for cls_ind, cls in enumerate(range(num_class)):#CLASSES[1:]\r\n cls_ind += 1 # because we skipped background\r\n # cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\r\n # cls_scores = scores[:, cls_ind]\r\n # dets = np.hstack((cls_boxes,\r\n # cls_scores[:, np.newaxis])).astype(np.float32)\r\n inds = np.where(scores[:, cls_ind] > thresh)[0]\r\n cls_scores = scores[inds, cls_ind]\r\n if cfg.TEST.AGNOSTIC:\r\n cls_boxes = boxes[inds, 4:8]\r\n else:\r\n cls_boxes = boxes[inds, cls_ind*4:(cls_ind+1)*4]\r\n dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \\\r\n .astype(np.float32, copy=False)\r\n keep = nms(dets, NMS_THRESH)\r\n dets = dets[keep, :]\r\n #vis_detections(im, cls, dets, thresh=CONF_THRESH)\r\n inds = np.where(dets[:, -1] >= thresh)[0]\r\n if len(inds) == 0:\r\n continue\r\n\r\n im_tmp = im#im[:, :, (2, 1, 0)]\r\n for i in inds:\r\n bbox = dets[i, :4]\r\n score = dets[i, -1]\r\n print bbox,score,cls\r\n cv2.rectangle(im_tmp, (bbox[0],bbox[1]), (bbox[2],bbox[3]), (0,0,255),2)\r\n #save_ff=\"/storage2/liushuai/faster_rcnn/FasterRCNN-Encapsulation-Cplusplus/faster_cxx_lib_ev2641/test_result.jpg\"\r\n im_tmp = im#im[:, :, (2, 1, 0)]\r\n cv2.imwrite(save_ff,im_tmp)\r\n #save_pic(im, cls, dets, thresh=CONF_THRESH,save_ff)\r","def determine_object_class(self, components_detected):\n for subimage, components in components_detected.items():\n\n for component in components:\n\n if component.class_id == 0:\n component.object_name = \"insl\" # Insulator\n\n elif component.class_id == 1:\n component.object_name = \"dump\" # Vibration dumper\n\n else:\n component.object_name = \"pillar\"","def __detect_objs(self):\n while True:\n # Wait for input images\n if (not self.__predict_start) or \\\n (self.__img is None):\n continue\n\n # Client for detection\n client = vision.ImageAnnotatorClient()\n\n # Encode image to binary\n _, img_buffer = cv2.imencode(\".jpg\", self.__img)\n img_bytes = img_buffer.tobytes()\n\n # Change to vision Image type\n image = vision.Image(content=img_bytes)\n # Detect Person\n self.__detect_info = client.object_localization(image=image,\n max_results=self.__max_results\n ).localized_object_annotations\n cv2.waitKey(30)","def detect_objects(self, image, threshold=0.5, needs_preprocessing=False, temp_path='temp.jpg',\n version='default'):\n if self.transform_service:\n image = self.transform_service.predict_single(image, version)\n return self.model_service.detect_objects(image, threshold, needs_preprocessing, temp_path)","def face_detect(sess, net, image_name):\n\n\t# Load the demo image\n\tim_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\n\tim = cv2.imread(im_file)\n\n\t# Detect all object classes and regress object bounds\n\ttimer = Timer()\n\ttimer.tic()\n\t# scores, boxes = im_detect(sess, net, im)\n\tscores, boxes, eyes, smiles = im_detect_ori(sess, net, im)\n\ttimer.toc()\n\tprint ('Detection took {:.3f}s for '\n\t\t\t'{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n\t# Visualize detections for each class\n\t# im = im[:, :, (2, 1, 0)]\n\t# fig, ax = plt.subplots(figsize=(8, 8))\n\t# ax.imshow(im, aspect='equal')\n\n\tCONF_THRESH = 0.9\n\tNMS_THRESH = 0.3\n\tfor cls_ind, cls in enumerate(CLASSES[20:]):\n\t\tcls_ind += 20 # because we skipped everything except face\n\t\tcls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n\t\tcls_scores = scores[:, cls_ind]\n\t\tdets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)\n\t\tkeep = nms(dets, NMS_THRESH)\n\t\tdets = dets[keep, :]\n\t\teye = eyes[keep, :]\n\t\tsmile= smiles[keep, :]\n\n\tinds = np.where(dets[:, -1] >= CONF_THRESH)[0]\n\tface_num = len(inds)\n\tprint '{} faces detected!'.format(face_num)\n\tdets = dets[inds, :]\n\teye = eye[inds, 1]\n\tsmile = smile[inds, 1]\n\n\treturn dets, eye, smile","def annotate_image(self, image, results):\n predictedObjects = []\n for i in range(len(results)):\n objectParameters = []\n x = int(results[i][1])\n y = int(results[i][2])\n w = int(results[i][3])\n h = int(results[i][4])\n # print(x, y, w, h, results[i][0])\n imageHeight, imageWidth, _ = image.shape\n w = w // 2\n h = h // 2\n # change to truncate boxes which go outside the image\n xmin, xmax, ymin, ymax = 0, 0, 0, 0\n xmin = 3 if not max(x - w, 0) else (x - w)\n xmax = imageWidth - 3 if not min(x + w - imageWidth, 0) \\\n else (x + w)\n ymin = 1 if not max(y - h, 0) else (y - h)\n ymax = imageHeight - 3 if not min(y + h - imageHeight, 0) \\\n else (y + h)\n if self.verbose:\n print('Class : ' + results[i][0] + ', [x, y, w, h] [' +\n str(x) + ', ' + str(y) + ', ' + str(w) + ', ' + str(h) +\n '] Confidence : ' + str(results[i][5]))\n \n # Each class must have a unique color\n color = tuple([(j * (1+self.classes.index(results[i][0])) % 255) \\\n for j in self.seed])\n cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)\n if ymin <= 20:\n cv2.rectangle(\n image, (xmin, ymin), (xmax, ymin + 20), color, -1\n )\n cv2.putText(\n image, results[i][0] + ': %.2f' % results[i][5],\n (xmin+5, ymin+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 2\n )\n else:\n cv2.rectangle(image, (xmin, ymin), (xmax, ymin-20), color, -1)\n cv2.putText(\n image, results[i][0] + ': %.2f' % results[i][5],\n (xmin+5, ymin-8), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 2\n )\n objectParameters = [\n results[i][0], xmin, ymin, xmax, ymax, results[i][5]\n ]\n predictedObjects.append(objectParameters)\n return image, predictedObjects\n # if self.outputFile:\n # cv2.imwrite(self.outputFile,image)","def demo(net, data_dir, imgfile, out_dir):\n\n # Load the demo image\n im_file = os.path.join(data_dir, imgfile)\n im = cv2.imread(im_file)\n\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(net, im)\n scores = np.squeeze(scores)\n timer.toc()\n print ('Detection took {:.3f}s for '\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n # Visualize detections for each class\n CONF_THRESH = 0.12\n NMS_THRESH = 0.3\n color_white = (0, 0, 0)\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 \n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n color = (random.randint(0, 256), random.randint(0, 256), random.randint(0, 256))\n inds = np.where(dets[:, -1] >= CONF_THRESH)[0]\n for i in inds:\n bbox = dets[i, :4]\n score = dets[i, -1]\n bbox = map(int, bbox)\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=4)\n cv2.putText(im, '%s %.3f' % (cls, score), (bbox[0], bbox[1] + 15),\n color=color_white, fontFace=cv2.FONT_HERSHEY_COMPLEX, fontScale=0.5)\n return im","def apply_classifier(self):\n for detected_object in self.detected_objects:\n detected_object.predict_class(self.original_image)","def classify_image(image):\n image_path = image.filename\n image_data = np.array(Image.open(image.stream))\n image_data = skimage.img_as_float(image_data).astype(np.float2)\n with classifier_lock:\n classification = classifier.predict([image_data])[0]\n return {\"suggested_tags\": predicted_tags(classification),\n \"classification_vector\": classification,\n \"image_url\": image_path}","def on_image(image):\n objects = [obj for obj in coco.classify(image) if obj.confidence > config.OBJECT_CONFIDENCE_THRESHOLD]\n queue.put((image, objects))","def detect_objects(snap):\n client = vision.ImageAnnotatorClient()\n print(snap)\n\n with open(snap, 'rb') as im_file:\n content = im_file.read()\n image = vision.Image(content=content)\n\n objects = client.object_localization(image=image).localized_object_annotations\n\n print(f\"Found {len(objects)} objects\")\n [print(f\"{objet.name} : {round(objet.score*100,2)}\") for objet in objects]\n \n return objects","def classify_images():\n\n # Load the desired image\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\n img = image.load_img(img_path, target_size=(299, 299))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n model = InceptionV3(weights=\"imagenet\")\n preds = model.predict(x)\n # decode the results into a list of tuples (class, description, probability)\n # (one such list for each sample in the batch)\n print('Predicted:', decode_predictions(preds, top=3)[0])","def get_object_detections(self):\n detections = self.__get_cropped_detections(self.image)\n return detections","def demo(net, image_name, classes):\n\n # Load pre-computed Selected Search object proposals\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\n obj_proposals = sio.loadmat(box_file)['boxes']\n\n # Load the demo image\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\n im_file = os.path.join(test_images_path, image_name + '.jpg')\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(net, im, obj_proposals)\n timer.toc()\n # print ('Detection took {:.3f}s for '\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n # Visualize detections for each class\n CONF_THRESH = 0\n NMS_THRESH = 0.3\n max_inds = 0\n max_score = 0.0\n for cls in classes:\n cls_ind = CLASSES.index(cls)\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n keep = np.where(cls_scores >= CONF_THRESH)[0]\n cls_boxes = cls_boxes[keep, :]\n cls_scores = cls_scores[keep]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\n # CONF_THRESH, image_name)\n #if get_max!=[]: \n\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\n #print image_name,cls,tmp\n\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\n #print dets[:,-1]\n #print image_name,max_score\n file.writelines([image_name,'\\t',cls,'\\t',str(tmp),'\\n'])\n if(max_score<tmp):\n max_score=tmp\n cls_max=cls\n print image_name,cls_max,max_score","def classify(self):\n infer = self.model.signatures['serving_default']\n for i, original_image in enumerate(self.images):\n image = original_image.copy()\n image = cv.cvtColor(image, cv.COLOR_BGR2RGB)\n image = cv.resize(image, (self.image_size, self.image_size))\n image = image / 255.\n\n image = [image]\n image = np.asarray(image).astype(np.float32)\n batch_data = tf.constant(image)\n pred_bbox = infer(batch_data)\n for key, value in pred_bbox.items():\n boxes = value[:, :, 0:4]\n pred_conf = value[:, :, 4:]\n\n boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(\n boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),\n scores=tf.reshape(\n pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),\n max_output_size_per_class=10,\n max_total_size=10,\n iou_threshold=FLAGS.iou,\n score_threshold=FLAGS.score\n )\n\n height, width, _ = original_image.shape\n\n print(scores)\n classes = classes[0]\n print(classes)\n\n bbox = boxes[0][0].numpy()\n bbox[0] = int(bbox[0] * height)\n bbox[2] = int(bbox[2] * height)\n bbox[1] = int(bbox[1] * width)\n bbox[3] = int(bbox[3] * width)\n\n if BIRD_CLASS in classes:\n idx = np.where(classes == BIRD_CLASS)\n bbox = bbox.astype(np.int)\n x = int((bbox[1] + bbox[3]) / 2)\n y = int((bbox[0] + bbox[2]) / 2)\n self.thumbnail_center.append((x, y))\n cropped_img = original_image[bbox[0]:bbox[2], bbox[1]: bbox[3]]\n self.bird_images.append(cropped_img)\n self.confidence_arr.append(scores[idx[0][0]][0])\n\n self.generate_thumbnail(size=150)","def classify_image_proba(image, model, image_box=None):\n images_list = []\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\n # box argument clips image to (x1, y1, x2, y2)\n image = np.array(image)\n images_list.append(image)\n \n return [np.amax(model.predict(np.array(images_list)))]","def detectObjects(image):\n\tgrayscale = cvCreateImage(cvSize(image.width, image.height), 8, 1)\n\tcvCvtColor(image, grayscale, CV_BGR2GRAY)\n\n\tstorage = cvCreateMemStorage(0)\n\tcvClearMemStorage(storage)\n\tcvEqualizeHist(grayscale, grayscale)\n\tcascade = cvLoadHaarClassifierCascade(\n\t\t'/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml',\n\t\tcvSize(1,1))\n\n\tscalefactor = 1.1 # How much to increase window size each pass\n\tminsize = 50 # Smallest face to detect. Up this if you have small falsepositives\n\tfaces = cvHaarDetectObjects(grayscale, cascade, storage, scalefactor, 50,\n\t\t\t\tCV_HAAR_DO_CANNY_PRUNING, cvSize(minsize, minsize))\n\n\treturn [(f.x, f.y, f.x + f.width, f.y + f.height) for f in faces]","def get_classification(self, image):\n #TODO implement light color prediction\n max_idx = 4\n with self.detection_graph.as_default():\n with tf.Session(graph=self.detection_graph) as sess:\n # Definite input and output Tensors for detection_graph\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\n \n # Each box represents a part of the image where a particular object was detected.\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\n \n # Each score represent how level of confidence for each of the objects.\n # Score is shown on the result image, together with the class label.\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image, axis=0)\n # Actual detection.\n (boxes, scores, classes, num) = sess.run(\n [detection_boxes, detection_scores, detection_classes, num_detections],\n feed_dict={image_tensor: image_np_expanded})\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n min_score_thresh = .50\n # find majority light state\n counter = [0, 0, 0, 0, 0]\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > min_score_thresh:\n counter[classes[i]] += 1\n for i in range(1, 5):\n if counter[i] > counter[max_idx]:\n max_idx = i\n return self.classmap[max_idx]","def compute_classifications(depc, gid_list, config=None):\n logger.info('[ibs] Process Image Classifications')\n logger.info('config = {!r}'.format(config))\n # Get controller\n ibs = depc.controller\n depc = ibs.depc_image\n if config['classifier_algo'] in ['cnn']:\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (192, 192),\n }\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\n result_list = ibs.generate_thumbnail_class_list(thumbnail_list, **config)\n elif config['classifier_algo'] in ['svm']:\n from wbia.algo.detect.svm import classify\n\n config_ = {'algo': 'resnet'}\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\n classifier_weight_filepath = config['classifier_weight_filepath']\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\n elif config['classifier_algo'] in ['densenet']:\n from wbia.algo.detect import densenet\n\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\n }\n thumbpath_list = ibs.depc_image.get(\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\n )\n result_list = densenet.test(thumbpath_list, ibs=ibs, gid_list=gid_list, **config)\n elif config['classifier_algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\n classifier_weight_filepath = config['classifier_weight_filepath']\n classifier_weight_filepath = classifier_weight_filepath.strip().split(';')\n\n assert len(classifier_weight_filepath) == 2\n classifier_algo_, model_tag_ = classifier_weight_filepath\n\n include_grid2 = config['classifier_algo'] in ['tile_aggregation']\n tid_list = ibs.scout_get_valid_tile_rowids(\n gid_list=gid_list, include_grid2=include_grid2\n )\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\n confidence_list = ibs.scout_wic_test(\n tid_list, classifier_algo=classifier_algo_, model_tag=model_tag_\n )\n\n gid_dict = {}\n for ancestor_gid, tid, confidence in zip(\n ancestor_gid_list, tid_list, confidence_list\n ):\n if ancestor_gid not in gid_dict:\n gid_dict[ancestor_gid] = []\n gid_dict[ancestor_gid].append(confidence)\n\n result_list = []\n for gid in tqdm.tqdm(gid_list):\n gid_confidence_list = gid_dict.get(gid, None)\n assert gid_confidence_list is not None\n best_score = np.max(gid_confidence_list)\n\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in ['densenet+neighbors']:\n raise NotImplementedError\n # ut.embed()\n # classifier_weight_filepath = config['classifier_weight_filepath']\n\n # all_bbox_list = ibs.get_image_bboxes(gid_list)\n # wic_confidence_list = ibs.scout_wic_test(gid_list, classifier_algo='densenet',\n # model_tag=classifier_weight_filepath)\n #\n # ancestor_gid_list = list(set(ibs.get_tile_ancestor_gids(gid_list)))\n # all_tile_list = list(set(ibs.scout_get_valid_tile_rowids(gid_list=ancestor_gid_list)))\n # all_bbox_list = ibs.get_image_bboxes(all_tile_list)\n # all_confidence_list = ibs.scout_wic_test(all_tile_list, classifier_algo='densenet',\n # model_tag=classifier_weight_filepath)\n #\n # TODO: USE THRESHOLDED AVERAGE, NOT MAX\n # result_list = []\n # for gid, wic_confidence in zip(gid_list, wic_confidence_list):\n # best_score = wic_confidence\n # for aid in aid_list:\n # wic_confidence_ = aid_conf_dict.get(aid, None)\n # assert wic_confidence_ is not None\n # best_score = max(best_score, wic_confidence_)\n #\n # if wic_confidence < 0.5:\n # best_key = 'negative'\n # best_score = 1.0 - best_score\n # else:\n # best_key = 'positive'\n # if best_score > wic_confidence:\n # recovered += 1\n # result = (best_score, best_key, )\n # result_list.append(result)\n elif config['classifier_algo'] in ['scout_detectnet']:\n import json\n\n json_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\n assert exists(json_filepath)\n with open(json_filepath, 'r') as json_file:\n values = json.load(json_file)\n annotations = values.get('annotations', {})\n\n gpath_list = ibs.get_image_paths(gid_list)\n gname_list = [split(gpath)[1] for gpath in gpath_list]\n\n result_list = []\n for gname in gname_list:\n annotation = annotations.get(gname, None)\n assert annotation is not None\n\n best_score = 1.0\n if len(annotation) == 0:\n best_key = 'negative'\n else:\n best_key = 'positive'\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in ['scout_detectnet_csv', 'scout_faster_rcnn_csv']:\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\n\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\n csv_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\n\n assert exists(manifest_filepath)\n assert exists(csv_filepath)\n\n manifest_dict = {}\n with open(manifest_filepath, 'r') as manifest_file:\n manifest_file.readline() # Discard column header row\n manifest_line_list = manifest_file.readlines()\n for manifest_line in manifest_line_list:\n manifest = manifest_line.strip().split(',')\n assert len(manifest) == 2\n manifest_filename, manifest_uuid = manifest\n manifest_dict[manifest_filename] = manifest_uuid\n\n csv_dict = {}\n with open(csv_filepath, 'r') as csv_file:\n csv_file.readline() # Discard column header row\n csv_line_list = csv_file.readlines()\n for csv_line in csv_line_list:\n csv = csv_line.strip().split(',')\n assert len(csv) == 2\n csv_filename, csv_score = csv\n csv_uuid = manifest_dict.get(csv_filename, None)\n assert (\n csv_uuid is not None\n ), 'Test image {!r} is not in the manifest'.format(\n csv,\n )\n csv_dict[csv_uuid] = csv_score\n\n result_list = []\n for uuid_str in uuid_str_list:\n best_score = csv_dict.get(uuid_str, None)\n assert best_score is not None\n\n if config['classifier_algo'] in ['scout_detectnet_csv']:\n assert best_score in ['yes', 'no']\n best_key = 'positive' if best_score == 'yes' else 'negative'\n best_score = 1.0\n elif config['classifier_algo'] in ['scout_faster_rcnn_csv']:\n best_score = float(best_score)\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n else:\n raise ValueError\n\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in [\n 'lightnet',\n 'densenet+lightnet',\n 'densenet+lightnet!',\n ]:\n min_area = 10\n\n classifier_weight_filepath = config['classifier_weight_filepath']\n classifier_weight_filepath = classifier_weight_filepath.strip().split(',')\n\n if config['classifier_algo'] in ['lightnet']:\n assert len(classifier_weight_filepath) == 2\n weight_filepath, nms_thresh = classifier_weight_filepath\n wic_thresh = 0.0\n nms_thresh = float(nms_thresh)\n wic_confidence_list = [np.inf] * len(gid_list)\n wic_filter = False\n elif config['classifier_algo'] in ['densenet+lightnet', 'densenet+lightnet!']:\n assert len(classifier_weight_filepath) == 4\n (\n wic_model_tag,\n wic_thresh,\n weight_filepath,\n nms_thresh,\n ) = classifier_weight_filepath\n wic_thresh = float(wic_thresh)\n nms_thresh = float(nms_thresh)\n wic_confidence_list = ibs.scout_wic_test(\n gid_list, classifier_algo='densenet', model_tag=wic_model_tag\n )\n wic_filter = config['classifier_algo'] in ['densenet+lightnet']\n else:\n raise ValueError\n\n flag_list = [\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\n ]\n if wic_filter:\n gid_list_ = ut.compress(gid_list, flag_list)\n else:\n gid_list_ = gid_list[:]\n config = {\n 'grid': False,\n 'algo': 'lightnet',\n 'config_filepath': weight_filepath,\n 'weight_filepath': weight_filepath,\n 'nms': True,\n 'nms_thresh': nms_thresh,\n 'sensitivity': 0.0,\n }\n prediction_list = depc.get_property(\n 'localizations', gid_list_, None, config=config\n )\n prediction_dict = dict(zip(gid_list_, prediction_list))\n\n result_list = []\n for gid, wic_confidence, flag in zip(gid_list, wic_confidence_list, flag_list):\n if not flag:\n best_key = 'negative'\n best_score = 1.0 - wic_confidence\n else:\n prediction = prediction_dict.get(gid, None)\n assert prediction is not None\n\n best_score = 0.0\n if prediction is not None:\n score, bboxes, thetas, confs, classes = prediction\n for bbox, conf in zip(bboxes, confs):\n xtl, ytl, w, h = bbox\n area = w * h\n if area >= min_area:\n best_score = max(best_score, conf)\n\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n else:\n raise ValueError(\n 'specified classifier algo is not supported in config = {!r}'.format(config)\n )\n\n # yield detections\n for result in result_list:\n yield result","def demo(sess, net, color_image, depth_colormap):\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, color_image)\n timer.toc()\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\n\n # Visualize detections for each class\n CONF_THRESH = 0.7\n NMS_THRESH = 0.3\n dets_col = []\n cls_col = []\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n dets_col.append(dets)\n cls_col.append(cls)\n\n vis_detections(color_image, depth_colormap, cls_col, dets_col, thresh=CONF_THRESH)\n\n depth_col, bbox_col = calc_histogram(depth_image, cls_col, dets_col, thresh=CONF_THRESH)\n print(\"box depth:\", depth_col[0], \"sucker depth:\", depth_col[1])\n print(\"box bbox:\", bbox_col[0], \"sucker bbox\", bbox_col[1])","def vis_detections(im, class_name, dets, thresh=0.8):\n\n dict = {'HolderA': 'Holder', 'WheelA': 'WheelA', 'WheelB': 'WheelB', 'BrakeA': 'Brake', 'SpringA': 'Spring',\n 'BuckleA': 'BuckleA', 'BuckleB': 'BuckleB', 'TubeA': 'Tube', 'NutA': 'NutA', 'ScrewA': 'ScrewA',\n 'NutB': 'NutB', 'ScrewB': 'ScrewB',\n 'WireA': 'Wire', 'PlateA': 'PlateA', 'PlateB': 'PlateB', 'PlateD': 'PlateC', 'PlateE': 'PlateD',\n 'BoltA': 'Bolt', 'LoopB': 'Loop', 'JointA': 'JointA', 'JointB': 'JointB', 'FixatorA': 'Fixator',\n 'BearingA': 'Bearing', 'PlugA': 'Plug'}\n\n for i in range(np.minimum(10, dets.shape[0])):\n bbox = tuple(int(np.round(x)) for x in dets[i, :4])\n score = dets[i, -1]\n if score > thresh:\n # Color site: http://www.wahart.com.hk/rgb.htm\n if class_name == 'HolderA':\n color = (255, 255, 0) # Cyan\n elif class_name == 'WheelA':\n color = (212, 255, 127) # Aquamarina\n elif class_name == 'WheelB':\n color = (99, 99, 238) # IndianRed2\n elif class_name == 'BrakeA':\n color = (99, 99, 238) # IndianRed2\n elif class_name == 'SpringA':\n color = (180, 130, 70) # SteelBlue\n elif class_name == 'BuckleA':\n color = (205, 0, 0) # MediumBlue\n elif class_name == 'BuckleB':\n color = (170, 205, 102) # MediumAquamarine\n elif class_name == 'BuckleC':\n color = (0, 252, 124) # LawnGreen\n elif class_name == 'BuckleD':\n color = (50, 205, 50) # LimeGreen\n elif class_name == 'TubeA':\n color = (147, 112, 219) # PaleVioletRed\n elif class_name == 'ScrewA':\n color = (240, 32, 160) # Purple\n elif class_name == 'ScrewB':\n color = (0, 165, 255) # Orange1\n elif class_name == 'ScrewC':\n color = (48, 48, 255) # Firebrick1\n elif class_name == 'NutA':\n color = (0, 255, 255) # Yellow\n elif class_name == 'NutB':\n color = (255, 144, 30) # DodgerBlue\n elif class_name == 'NutC':\n color = (180, 238, 180) # DarkSeaGreen2\n elif class_name == 'WireA':\n color = (255, 255, 255) # White\n elif class_name == 'PlateA':\n color = (0, 69, 255) # OrangeRed\n elif class_name == 'PlateB':\n color = (102, 205, 0) # SpringGreen3\n elif class_name == 'PlateD':\n color = (0, 255, 0) # Green\n elif class_name == 'PlateE':\n color = (0, 140, 250) # DarkOrange\n elif class_name == 'BoltA':\n color = (255, 255, 0) # Cyan\n elif class_name == 'LoopB':\n color = (180, 105, 255) # HotPink\n elif class_name == 'JointA':\n color = (105, 140, 255) # Salmon1\n elif class_name == 'JointB':\n color = (255, 0, 255) # Magenta3\n elif class_name == 'FixatorA':\n color = (0, 205, 102) # Chartreuse3\n elif class_name == 'BearingA':\n color = (185, 218, 255) # PeachPuff\n elif class_name == 'PlugA':\n color = (193, 193, 255) # RosyBrown1\n else:\n color = (139, 0, 139) # DarkMagenta\n cv2.rectangle(im, bbox[0:2], bbox[2:4], color, 2)\n # cv2.putText(im, '%s: %.3f' % (class_name, score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_COMPLEX,\n # 0.5, color, thickness=1)\n cv2.putText(im, '%s: %.3f' % (dict[class_name], score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_COMPLEX,\n 0.5, color, thickness=1)\n return im","def detect(original_image, min_score, max_overlap, top_k, suppress=None):\n\n\t# Transform\n\timage = normalize(to_tensor(resize(original_image)))\n\n\t# Move to default device\n\timage = image.to(device)\n\n\t# Forward prop.\n\tpredicted_locs, predicted_scores = model(image.unsqueeze(0))\n\n\t# Detect objects in SSD output\n\tdet_boxes, det_labels, det_scores = model.detect_objects(predicted_locs, predicted_scores, min_score=min_score,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t max_overlap=max_overlap, top_k=top_k)\n\n\t# Move detections to the CPU\n\tdet_boxes = det_boxes[0].to('cpu')\n\n\t# Transform to original image dimensions\n\toriginal_dims = torch.FloatTensor(\n\t\t[original_image.width, original_image.height, original_image.width, original_image.height]).unsqueeze(0)\n\tdet_boxes = det_boxes * original_dims\n\n\t# Decode class integer labels\n\tdet_labels = [rev_label_map[l] for l in det_labels[0].to('cpu').tolist()]\n\n\t# If no objects found, the detected labels will be set to ['0.'], i.e. ['background'] in SSD300.detect_objects() in model.py\n\tif det_labels == ['background']:\n\t\t# Just return original image\n\t\treturn original_image\n\n\t# Annotate\n\tannotated_image = original_image\n\tdraw = ImageDraw.Draw(annotated_image)\n\tfont = ImageFont.truetype(\"./arial.ttf\", 15)\n\n\t# Suppress specific classes, if needed\n\tfor i in range(det_boxes.size(0)):\n\t\tif suppress is not None:\n\t\t\tif det_labels[i] in suppress:\n\t\t\t\tcontinue\n\n\t\t# Boxes\n\t\tbox_location = det_boxes[i].tolist()\n\t\tdraw.rectangle(xy=box_location, outline=label_color_map[det_labels[i]])\n\t\tdraw.rectangle(xy=[l + 1. for l in box_location], outline=label_color_map[\n\t\t\tdet_labels[i]]) # a second rectangle at an offset of 1 pixel to increase line thickness\n\t\t# draw.rectangle(xy=[l + 2. for l in box_location], outline=label_color_map[\n\t\t# det_labels[i]]) # a third rectangle at an offset of 1 pixel to increase line thickness\n\t\t# draw.rectangle(xy=[l + 3. for l in box_location], outline=label_color_map[\n\t\t# det_labels[i]]) # a fourth rectangle at an offset of 1 pixel to increase line thickness\n\n\t\t# Text\n\t\ttext_size = font.getsize(det_labels[i].upper())\n\t\ttext_location = [box_location[0] + 2., box_location[1] - text_size[1]]\n\t\ttextbox_location = [box_location[0], box_location[1] - text_size[1], box_location[0] + text_size[0] + 4.,\n\t\t\t\t\t\t\tbox_location[1]]\n\t\tdraw.rectangle(xy=textbox_location, fill=label_color_map[det_labels[i]])\n\t\tdraw.text(xy=text_location, text=det_labels[i].upper(), fill='white',\n\t\t\t\t font=font)\n\tdel draw\n\n\treturn annotated_image","def apply_heuristics(obj_class: str, box_dimensions: list) -> list:\n # RULE to crop pedestrian and car object regions\n # Alter the box_dimensions in order to crop object regions based on class\n left_point, top_point, box_width, box_height = box_dimensions # unpack box size\n\n # For vehicles, crop out the upper 50% - this should remove the window reflections\n if obj_class in ['car', 'truck', 'bus']:\n box_height = int(box_height // 2)\n top_point = top_point + box_height\n elif obj_class in ['person, bicycle', 'motorbike']:\n # For pedestrians and bicycles, crop out the ground beneath them - the lower 20%\n top_point = top_point + int(box_height // 5)\n box_height = int(box_height // 1.25)\n return [left_point, top_point, box_width, box_height]","def demo(sess, net, image_name):\n # Load the demo image\n global CLASS_NAME\n global CHECK\n CHECK = 0\n # 读取的截图所在的位置\n # im_file = Cnn_path + \"data/VOCdevkit2007/VOC2007/JPEGImages/\" + image_name\n curpath = os.path.dirname(os.path.realpath(__file__))\n im_file = curpath + \"\\\\data\\\\VOCdevkit2007\\\\VOC2007\\\\JPEGImages\\\\\" + image_name\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, im)\n timer.toc()\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\n\n # Visualize detections for each class\n # score 阈值，最后画出候选框时需要，>thresh才会被画出\n CONF_THRESH = 0.5\n # 非极大值抑制的阈值，剔除重复候选框\n NMS_THRESH = 0.3\n # 利用enumerate函数，获得CLASSES中 类别的下标cls_ind和类别名cls\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 # because we skipped background\n # 取出bbox ,score\n cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n # 将bbox,score 一起存入dets\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n # 进行非极大值抑制，得到抑制后的 dets\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n # 画框\n vis_detections(im, cls, dets, thresh=CONF_THRESH)\n if CHECK == 0:\n CLASS_NAME = \"None\"\n # im = im[:, :, (2, 1, 0)]\n # fig, ax = plt.subplots()\n # ax.imshow(im, aspect='equal')\n # ax.set_title(\"None\",fontsize=10)\n # plt.axis('off')\n # plt.tight_layout()\n # plt.draw()\n # RES[INDS.__getitem__(image_name.split(\"_\")[0])][INDS.__getitem__(CLASS_NAME)]+=1\n # plt.savefig(\"./output/\"+CLASS_NAME+\"_\" + image_name)\n # plt.savefig(\"./output/\" + image_name)\n MAX_SCORE[0] = 0.0","def eval_pascal_one_class(pascal, detections, c):\n gts = {} \n num_objs = 0 \n for img_name in pascal:\n gts[img_name] = []\n for obj in pascal[img_name]:\n if obj['class_id'] == c and obj['difficult']==0:\n gts[img_name] += [{'bbox':obj['bbox'], 'detected': False}]\n num_objs += 1\n\n dts = []\n scores = []\n num_dets = 0\n for img_name in detections:\n for dt in detections[img_name]:\n if dt['class_id'] == c:\n dts.append([img_name, dt['bbox'], dt['score']])\n scores.append(dt['score'])\n num_dets += 1\n \n # Sort the detections based on their scores\n scores = np.array(scores, np.float32)\n sorted_idx = np.argsort(scores)[::-1]\n\n tp = np.zeros((num_dets))\n fp = np.zeros((num_dets))\n\n for i in tqdm(list(range(num_dets))):\n idx = sorted_idx[i]\n img_name = dts[idx][0]\n bbox = dts[idx][1] \n gt_bboxes = np.array([obj['bbox'] for obj in gts[img_name]], np.float32) \n\n # Compute the max IoU of current detection with the ground truths\n max_iou = 0.0\n if gt_bboxes.size > 0:\n ixmin = np.maximum(gt_bboxes[:, 0], bbox[0])\n iymin = np.maximum(gt_bboxes[:, 1], bbox[1])\n ixmax = np.minimum(gt_bboxes[:, 2], bbox[2])\n iymax = np.minimum(gt_bboxes[:, 3], bbox[3])\n\n iw = np.maximum(ixmax - ixmin + 1.0, 0.0)\n ih = np.maximum(iymax - iymin + 1.0, 0.0)\n\n area_intersect = iw * ih\n area_union = (bbox[2] - bbox[0] + 1.0) * (bbox[3] - bbox[1] + 1.0) + (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1.0) * (gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1.0) - area_intersect\n\n ious = area_intersect / area_union\n max_iou = np.max(ious, axis=0)\n j = np.argmax(ious)\n\n # Determine if the current detection is a true or false positive\n if max_iou > 0.5:\n if not gts[img_name][j]['detected']:\n tp[i] = 1.0\n gts[img_name][j]['detected'] = True\n else:\n fp[i] = 1.0\n else:\n fp[i] = 1.0\n\n # Accumulate the numbers of true and false positives\n tp = np.cumsum(tp)\n fp = np.cumsum(fp)\n\n # Compute the average precision based on these data\n rec = tp * 1.0 / num_objs\n prec = tp * 1.0 / np.maximum((tp + fp), np.finfo(np.float64).eps)\n\n mrec = np.concatenate(([0.], rec, [1.]))\n mpre = np.concatenate(([0.], prec, [0.]))\n\n for i in range(mpre.size - 1, 0, -1):\n mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\n\n i = np.where(mrec[1:] != mrec[:-1])[0]\n\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\n print('average precision for class %s = %f' %(pascal_class_names[c], ap))\n\n return ap","def get_classification(self, image):\n if self.correct_gamma:\n if self.gamma == 1.0:\n self.gamma = 0.6\n elif self.gamma == 0.6:\n self.gamma = 1.0\n image = self.adjust_gamma(image, self.gamma)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n image_np = np.asarray(image, dtype=\"uint8\")\n image_np_expanded = np.expand_dims(image_np, axis=0)\n\n detected = False\n\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n boxes = np.squeeze(boxes)\n classes = np.squeeze(classes).astype(np.int32)\n scores = np.squeeze(scores)\n best_scores = []\n\n for idx, classID in enumerate(classes):\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\n if classID == 10: # 10 is traffic light\n if scores[idx] > 0.10: #confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n else: # we tuned the model to classify only traffic lights\n if scores[idx] > 0.10: # confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n\n tl_index = TrafficLight.UNKNOWN\n if detected:\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\n\n best_score = best_scores[0]\n rospy.logdebug(\"number of TL found %d, best score: %f, color: %f\", len(best_scores), best_score[0], best_score[2])\n nbox = boxes[best_score[1]]\n\n height = image.shape[0]\n width = image.shape[1]\n\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\n box_height = box[2] - box[0]\n box_width = box[3] - box[1]\n ratio = float(box_height)/float(box_width)\n rospy.logdebug(\"ratio: %f\", ratio)\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\n tl_color, tl_index = self.get_color(tl_cropped)\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\n #tl_index = best_score[2]\n #tl_color = color[tl_index]\n #augment image with detected TLs\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\n font = cv2.FONT_HERSHEY_SIMPLEX\n font_color = (255, 255, 255)\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\n return image, tl_index","def object_detect(filename):\n cv2.ocl.setUseOpenCL(False)\n just_fname = filename.split(\".\")[0]\n image = cv2.imread('./static/uploads/' + filename)\n bbox, label, conf = cv.detect_common_objects(image)\n output_image = draw_bbox(image, bbox, label, conf)\n plt.imshow(output_image)\n plt.savefig(os.path.join('./static/output/', just_fname + '.png'))\n d = Counter(label)\n if not label:\n return \"No objects detected\"\n labelstr = \", \".join('{} {}'.format(v, k) for k, v in d.items())\n return labelstr","def __get_coco_masks(anns: list, img):\n width = img.shape[1]\n height = img.shape[0]\n\n if len(anns) == 0:\n raise AnnError('Empty annotation detected.')\n \n classes = []\n mask = np.zeros((height, width), dtype=np.int32)\n \n for inst_idx, ann in enumerate(anns):\n cat_id = ann['category_id']\n classes.append(cat_id)\n\n m = cocoseg_to_binary(ann['segmentation'], height, width) # zero one mask\n m = m.astype(np.int32) * (inst_idx + 1)\n mask[m > 0] = 255\n\n classes = np.asarray(classes)\n return mask, classes","def object_detection(self):\r\n pass","def get_candidate_objects(output, img_size, classes, anchors, threshold):\n\n #threshold = 0.8\n iou_threshold = 0.4\n\n boxes, probs = parse_yolo_output_v2(output, img_size, len(classes), anchors)\n filter_mat_probs = (probs >= threshold)\n filter_mat_boxes = np.nonzero(filter_mat_probs)[0:3]\n boxes_filtered = boxes[filter_mat_boxes]\n probs_filtered = probs[filter_mat_probs]\n classes_num_filtered = np.argmax(probs, axis=3)[filter_mat_boxes]\n\n idx = np.argsort(probs_filtered)[::-1]\n boxes_filtered = boxes_filtered[idx]\n probs_filtered = probs_filtered[idx]\n classes_num_filtered = classes_num_filtered[idx]\n\n # too many detections - exit\n if len(boxes_filtered) > 1e3:\n print(\"Too many detections, maybe an error? : {}\".format(\n len(boxes_filtered)))\n return []\n\n probs_filtered = non_maxima_suppression(boxes_filtered, probs_filtered,\n classes_num_filtered, iou_threshold)\n\n filter_iou = (probs_filtered > 0.0)\n boxes_filtered = boxes_filtered[filter_iou]\n probs_filtered = probs_filtered[filter_iou]\n classes_num_filtered = classes_num_filtered[filter_iou]\n\n result = []\n for class_id, box, prob in zip(classes_num_filtered, boxes_filtered, probs_filtered):\n result.append([classes[class_id], box[0], box[1], box[2], box[3], prob])\n\n return result","def classify_face(im):\n faces_death = get_encoded_faces_deaths()\n faces_arrested = get_encoded_faces_arrested()\n faces_wanted = get_encoded_faces_wanted()\n\n faces_encoded_death = list(faces_death.values())\n known_face_names_death = list(faces_death.keys())\n\n faces_encoded_arrested = list(faces_arrested.values())\n known_face_names_arrested = list(faces_arrested.keys())\n\n faces_encoded_wanted = list(faces_wanted.values())\n known_face_names_wanted = list(faces_wanted.keys())\n\n img = cv2.imread(im, 1)\n face_locations = face_recognition.face_locations(img)\n unknown_face_encodings = face_recognition.face_encodings(img,face_locations)\n face_names = []\n find_in_db(im,known_face_names_death,unknown_face_encodings,face_names,faces_encoded_death,\"unnatural_death_images/unnatural_death_images\")\n find_in_db(im,known_face_names_arrested,unknown_face_encodings,face_names,faces_encoded_arrested,\"ArrestPerson_images\")\n find_in_db(im,known_face_names_wanted,unknown_face_encodings,face_names,faces_encoded_wanted,\"wanted\")","def hog_extra_and_svm_class(proposal, clf, resize = (64, 64)):\n img = cv2.cvtColor(proposal, cv2.COLOR_BGR2GRAY)\n img = cv2.resize(img, resize)\n bins = 9\n cell_size = (8, 8)\n cpb = (2, 2)\n norm = \"L2\"\n features = ft.hog(img, orientations=bins, pixels_per_cell=cell_size, \n cells_per_block=cpb, block_norm=norm, transform_sqrt=True)\n print \"feature = \", features.shape\n features = np.reshape(features, (1,-1))\n cls_prop = clf.predict_proba(features)\n print(\"type = \", cls_prop)\n print \"cls prop = \", cls_prop\n return cls_prop","def find_objects(image, **kw):\n # This OpenCV based approach is MUCH slower:\n # objects = list()\n # for label in range(max_label+1 if max_label else amax(image)):\n # mask = array(image==(label+1), uint8)\n # if mask.any():\n # x, y, w, h = cv2.boundingRect(mask)\n # objects.append(sl.box(y,y+h,x,x+w))\n # else:\n # objects.append(None)\n # return objects\n try: return measurements.find_objects(image,**kw)\n except: pass\n types = [\"int32\",\"uint32\",\"int64\",\"uint64\",\"int16\",\"uint16\"]\n for t in types:\n try: return measurements.find_objects(array(image,dtype=t),**kw)\n except: pass\n # let it raise the same exception as before\n return measurements.find_objects(image,**kw)","def calculate_classifiers(self, segmented_image, grand_truth_image):\n grand_truth_image = np.array(grand_truth_image)\n\n rows = grand_truth_image.shape[0]\n cols = grand_truth_image.shape[1]\n\n global TP, FP, TN, FN, RN\n\n TP, FP, TN, FN, RN = 0, 0, 0, 0, 0\n\n # It calculates the classifers\n for x in range(0, rows):\n for y in range(0, cols):\n\n if grand_truth_image[x][y] == 255 and segmented_image[x][y] == 255:\n TP += 1\n elif grand_truth_image[x][y] == 0 and segmented_image[x][y] == 255:\n FP += 1\n elif grand_truth_image[x][y] == 0 and segmented_image[x][y] == 0:\n TN += 1\n elif grand_truth_image[x][y] == 255 and segmented_image[x][y] == 0:\n FN += 1\n else:\n RN += 1","def draw_pred(image: np.ndarray, class_name: str, box_dimensions: list, distance: float) -> None:\n\n # Params describes the amount of scaling in each of the rgb channels to produce a different color for each class\n # The main object classes have different colours to make them easier to distinguish\n params = {\"car\": (1, 0.85, 0.678), \"person\": (0, 0, 1), \"truck\": (0.33, 1, 0.5), \"bus\": (0.506, 0.149, 0.965)}\n if class_name in params:\n colour_scale = params[class_name] # get the colour values from the colour dictionary\n else:\n colour_scale = (0.90, 0.85, 0.678) # standard colour for less frequently occurring objects\n\n # Choose the brightness of the colour depending on distance away\n # Objects that are further away have a darker shade of their class colour\n # This gets brighter as the object gets closer - enables us to better visualise the depth predictions\n tone = 255 - (min(distance, 50)/50)*255\n colour = (tone * colour_scale[0], tone * colour_scale[1], tone * colour_scale[2])\n\n # Draw a bounding box.\n left, top, box_width, height = box_dimensions # unpack the box tuple\n cv2.rectangle(image, (left, top), (left + box_width, top + height), colour, 2)\n object_label = ' %s : %.2fm' % (class_name, distance) # construct label\n\n # Display the label at the top of the bounding box\n labelSize, baseLine = cv2.getTextSize(object_label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\n top = max(top, labelSize[1])\n cv2.rectangle(image, (left, top - round(1.5*labelSize[1])),\n (left + round(1.5*labelSize[0]), top + baseLine), (255, 255, 255), cv2.FILLED)\n cv2.rectangle(image, (left, top - round(1.5*labelSize[1])), (left + round(1.5*labelSize[0]), top + baseLine),\n (0, 0, 0))\n cv2.putText(image, object_label, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA)","def detect_objects(self, pred_locs, pred_scores, min_score, max_overlap, top_k):\n batch_size = pred_locs.size(0)\n n_priors = self.priors_cxcy.size(0)\n # Calculate softmax over class labels. (object vs background)\n pred_scores = F.softmax(pred_scores, dim=2) # (N, 1930, 2)\n\n # Lists to store final predicted boxes, labels, and scores for all images\n all_images_boxes = list()\n all_images_labels = list()\n all_images_scores = list()\n\n assert n_priors == pred_locs.size(1) == pred_scores.size(1)\n\n for i in range(batch_size):\n # Decode object coordinates from the form we regressed predicted boxes to\n # these are fractional point coordinates\n decoded_locations = cxcy_to_xy(gcxgcy_to_cxcy(pred_locs[i], self.priors_cxcy)) # (1930, 4),\n\n # Lists to store boxes and scores for this image\n image_boxes = list()\n image_labels = list()\n image_scores = list()\n\n # Keep object class scores where object is present, we need not calculate the score\n # for background. This score is thresholded by minimum score\n\n object_class_scores = pred_scores[i][:, 1] # (1930)\n score_above_min_score = object_class_scores > min_score # torch.bool\n # number of box_prediction with good confidence score for object class\n n_above_min_score = score_above_min_score.sum().item()\n\n # Pull the scores of object class above minimum scores\n object_class_scores = object_class_scores[score_above_min_score] # (n_qualified)\n # Pull decoded locations for the object class with qualified score\n class_decoded_locs = decoded_locations[score_above_min_score] # (n_qualified, 4)\n\n # Sorting the predicted boxes and scores by object class scores\n # (n_qualified), (n_min_score)\n object_class_scores, sort_ind = object_class_scores.sort(dim=0, descending=True)\n class_decoded_locs = class_decoded_locs[sort_ind] # (n_min_score, 4)\n\n # Find the overlap among predicted boxes\n overlap = find_jaccard_overlap(class_decoded_locs, class_decoded_locs) # (n_qualified, n_min_score)\n\n # Non-Maximum Suppression (NMS)\n # This technique is used to eliminate boxes which represent same object in the image\n # Here we use suppress tensor to keep track of boxes which we need to supress\n # Value of 1 means suppress and value of 0 means don't suppress\n suppress = torch.zeros((n_above_min_score), dtype=torch.uint8).to(device) # (n_qualified)\n\n # Consider each box in order of decreasing scores\n for box in range(class_decoded_locs.size(0)):\n # If the box is already suppressed then continue\n if suppress[box] == 1:\n continue\n\n # Otherwise suppress boxes whose overlaps with this box, are greater than maximum overlap\n # Find these boxes and update the suppress index\n boxes_ovrlp_gthn_max_ovrlp = overlap[box] > max_overlap\n boxes_ovrlp_gthn_max_ovrlp = torch.tensor(boxes_ovrlp_gthn_max_ovrlp, dtype=torch.uint8)\n suppress = torch.max(suppress, boxes_ovrlp_gthn_max_ovrlp)\n\n # Don't suppress this box, even though it has an overlap of 1 with itself\n suppress[box] = 0\n\n # Store only unsuppressed boxes for this class\n image_boxes.append(class_decoded_locs[1 - suppress])\n image_labels.append(torch.LongTensor((1 - suppress).sum().item() * [1]).to(device))\n image_scores.append(object_class_scores[1 - suppress])\n\n # If the object is not present in the image, it is the 'background'\n if len(image_boxes) == 0:\n image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(device))\n image_labels.append(torch.LongTensor([0]).to(device))\n image_scores.append(torch.FloatTensor([0.]).to(device))\n\n # Concatenating all the objects in an image, into single tensor\n image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4)\n image_labels = torch.cat(image_labels, dim=0) # (n_objects)\n image_scores = torch.cat(image_scores, dim=0) # (n_objects)\n n_objects = image_scores.size(0)\n\n # Save only top_k confident objects\n if n_objects > top_k:\n image_scores, sort_ind = image_scores.sort(dim=0, descending=True)\n image_scores = image_scores[:top_k] # (top_k)\n image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4)\n image_labels = image_labels[sort_ind][:top_k] # (top_k)\n\n # Append to lists that store predicted boxes and scores for all images\n all_images_boxes.append(image_boxes)\n all_images_labels.append(image_labels)\n all_images_scores.append(image_scores)\n\n return all_images_boxes, all_images_labels, all_images_scores # lists of length batch_size","def forward(sess, net, img, CONF_THRESH=0.8, NMS_THRESH=0.7):\n\n results = {'face': [],\n 'lp': []}\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, img)\n timer.toc()\n\n for cls in ('face', 'lp') :# enumerate(CLASSES[1:]):\n cls_ind = CLASSES.index(cls) # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n results[cls] = [\n [x0, y0, x1-x0, y1-y0] for (x0, y0, x1, y1, score) in dets[keep, :]]\n\n return results, timer.total_time","def classify(self, image, nclasses, gamma):\n\n nclasses = nclasses + 1 # One extra class for the background\n energy_sum = [1e-05]\n\n com = ConstantObservationModel()\n icm = IteratedConditionalModes()\n\n if image.max() > 1:\n image = np.interp(image, [0, image.max()], [0.0, 1.0])\n\n mu, sigma = com.initialize_param_uniform(image, nclasses)\n p = np.argsort(mu)\n mu = mu[p]\n sigma = sigma[p]\n sigmasq = sigma ** 2\n\n neglogl = com.negloglikelihood(image, mu, sigmasq, nclasses)\n seg_init = icm.initialize_maximum_likelihood(neglogl)\n\n mu, sigma = com.seg_stats(image, seg_init, nclasses)\n sigmasq = sigma ** 2\n\n zero = np.zeros_like(image) + 0.001\n zero_noise = add_noise(zero, 10000, 1, noise_type='gaussian')\n image_gauss = np.where(image == 0, zero_noise, image)\n\n final_segmentation = np.empty_like(image)\n initial_segmentation = seg_init.copy()\n\n max_iter = 100\n tolerance = 1e-05\n\n for i in range(max_iter):\n\n if self.verbose:\n print('>> Iteration: ' + str(i))\n\n PLN = icm.prob_neighborhood(seg_init, beta, nclasses)\n PVE = com.prob_image(image_gauss, nclasses, mu, sigmasq, PLN)\n\n mu_upd, sigmasq_upd = com.update_param(image_gauss,\n PVE, mu, nclasses)\n ind = np.argsort(mu_upd)\n mu_upd = mu_upd[ind]\n sigmasq_upd = sigmasq_upd[ind]\n\n negll = com.negloglikelihood(image_gauss, mu_upd, sigmasq_upd, nclasses)\n final_segmentation, energy = icm.icm_ising(negll, beta, seg_init)\n energy_sum.append(energy[energy > -np.inf].sum())\n\n if self.save_history:\n self.segmentations.append(final_segmentation)\n self.pves.append(PVE)\n self.energies.append(energy)\n self.energies_sum.append(energy[energy > -np.inf].sum())\n\n if i % 10 == 0 and i != 0:\n\n tol = tolerance * (np.amax(energy_sum) - np.amin(energy_sum))\n\n test_dist = np.absolute(np.amax(energy_sum[np.size(energy_sum) - 5: i]) -\n np.amin(energy_sum[np.size(energy_sum) - 5: i]))\n\n if test_dist < tol:\n\n break\n\n seg_init = final_segmentation.copy()\n mu = mu_upd.copy()\n sigmasq = sigmasq_upd.copy()\n\n PVE = PVE[..., 1:]\n\n return initial_segmentation, final_segmentation, PVE","def infer_classes(png_fname):\n # 1 as speech\n \n from fastai.vision.image import open_image\n classes = model_classes.predict(open_image(png_fname))\n\n return classes","def image_classes():\n\n image_data_path = PROJECT_ROOT + \"/data/CUB_200_2011/\"\n\n # <class_id> <class_name>\n classes = open(image_data_path + \"classes.txt\").readlines()\n classes = [i.strip().split() for i in classes]\n\n # <image_id> <class_id>\n labels = open(image_data_path + \"image_class_labels.txt\").readlines()\n labels = [i.strip().split() for i in labels]\n\n class_ids = {}\n for i in classes:\n class_ids[i[1]] = int(i[0])\n\n label_ids = {}\n for i in labels:\n label_ids[int(i[0])] = int(i[1])\n\n return class_ids, label_ids","def object_detector(detector, img_location: str, num_detection=5 ) -> list:\n img = PIL.Image.open(img_location)\n img = np.array(img)\n img = tf.expand_dims(img, axis=0)\n result = detector(img)\n\n ret = []\n\n for i in range(num_detection):\n detection_class_number = int(result['detection_classes'].numpy()[0][i])\n detection_class_name = CLASSES_90[detection_class_number]\n\n detection_score = result['detection_scores'].numpy()[0][i]\n rounded_detection_score = round(float(detection_score), 2)\n\n # Append as a tuple\n ret.append( (detection_class_name, rounded_detection_score) )\n\n return ret","def visualize_detection(self, img, dets, classes=[], thresh=0.6):\n import matplotlib.pyplot as plt\n import random\n plt.imshow(img)\n height = img.shape[0]\n width = img.shape[1]\n colors = dict()\n for det in dets:\n (klass, score, x0, y0, x1, y1) = det\n if score < thresh:\n continue\n cls_id = int(klass)\n if cls_id not in colors:\n colors[cls_id] = (random.random(), random.random(), random.random())\n xmin = int(x0 * width)\n ymin = int(y0 * height)\n xmax = int(x1 * width)\n ymax = int(y1 * height)\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\n ymax - ymin, fill=False,\n edgecolor=colors[cls_id],\n linewidth=3.5)\n plt.gca().add_patch(rect)\n class_name = str(cls_id)\n if classes and len(classes) > cls_id:\n class_name = classes[cls_id]\n plt.gca().text(xmin, ymin - 2,\n '{:s} {:.3f}'.format(class_name, score),\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\n fontsize=12, color='white')\n plt.show()","def get_classification(self, image):\n\n image_np_expanded = np.expand_dims(image, axis=0)\n\n # Perform network inference\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores,\n self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n\n if self.RUNNING_ON_CARLA == True:\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > .05:\n if classes[i] == 10:\n classname = self.category_index[classes[i]]['name']\n print(classname, scores[i])\n\n # Extract image from best bounding box and pass through light classifier\n ymin, xmin, ymax, xmax = boxes[i]\n im_height, im_width, im_depth = image.shape\n (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)\n tf_image_cropped = image[int(top):int(bottom), int(left):int(right), :]\n\n PILImage = Image.fromarray(tf_image_cropped)\n resized_img = PILImage.resize((85, 256), Image.ANTIALIAS)\n image_np_resized = self.load_image_into_numpy_array(resized_img)\n x = np.expand_dims(image_np_resized, axis=0)\n x = np.vstack([x])\n\n #model = load_model('tf_classifier_1.h5')\n #model.compile(loss='categorical_crossentropy',\n # optimizer='adam',\n # metrics=['accuracy'])\n classes = self.keras_model.predict_classes(x, batch_size=1)\n print(classes)\n\n if classes[0] == 0:\n self.current_light = TrafficLight.GREEN\n elif classes[0] == 2:\n self.current_light = TrafficLight.YELLOW\n else:\n self.current_light = TrafficLight.RED\n\n break\n\n else:\n # Check the detections. If it has a good score\n # then set the current light to the detected label. The\n # first one is always the best (they are returned sorted \n # in score order).\n # Note that we have trained for 14 categories, including\n # left/right arrows etc. Here we are only looking for \n # standard red, yellow and green light and ignore others.\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > .05:\n classname = self.category_index[classes[i]]['name']\n print(classname, scores[i])\n\n if classname == 'Green':\n self.current_light = TrafficLight.GREEN\n elif classname == 'Yellow':\n self.current_light = TrafficLight.YELLOW\n elif classname == 'Red':\n self.current_light = TrafficLight.RED\n else:\n self.current_light = TrafficLight.UNKNOWN\n\n break\n\n return self.current_light","def detect_from_img(self, img, up_sample=DEFAULT_UPSAMPLING):\n # \"\"\"\n # Args:\n # img (numpy.ndarray): image loaded with scikit-image\n # up_sample (int): integer to specifiy if we should perform upsampling (optional)\n #\n # Returns:\n # detections (list): the detections as a list of dict with keys ``left``, ``top``, ``right``,\n # ``bottom``, ``score``)\n # \"\"\"\n raise NotImplementedError('detect_from_img')","def my_evaluate(original_image, img_id, annotations, min_score=0.4, max_overlap=0.3, top_k=200):\n\n # Transform\n image = normalize(to_tensor(resize(original_image)))\n\n # Move to default device\n image = image.to(device)\n\n # Forward prop.\n predicted_locs, predicted_scores = model(image.unsqueeze(0))\n\n # Detect objects in SSD output\n det_boxes, det_labels, det_scores = model.detect_objects(predicted_locs, predicted_scores, min_score=min_score,\n max_overlap=max_overlap, top_k=top_k)\n\n # Move detections to the CPU\n det_boxes = det_boxes[0].to('cpu')\n\n # Transform to original image dimensions\n original_dims = torch.FloatTensor(\n [original_image.width, original_image.height, original_image.width, original_image.height]).unsqueeze(0)\n det_boxes = det_boxes * original_dims\n\n # Decode class integer labels\n det_labels = [rev_label_map[l] for l in det_labels[0].to('cpu').tolist()]\n det_scores = det_scores[0].to('cpu').tolist()\n\n if det_labels != ['background']:\n for i in range(det_boxes.size(0)):\n \n # For every detection, see whether it matches a ground truth\n match = False\n for j in range(len(annotations['boxes'])):\n if annotations['labels'][j] == -1: # this is being set when a ground truth already matched\n continue\n match = box_match(det_boxes[i], \n det_labels[i], \n torch.Tensor(annotations['boxes'][j]), \n rev_label_map[annotations['labels'][j]])\n if match:\n annotations['labels'][j] = -1\n break\n \n if match: # true positive if the detection is correct and matched a ground truth\n all_results['true_positive'] += 1\n else: # false positive if the detection did not match a ground truth\n all_results['false_positive'] += 1\n \n # After all detections were checked, let us see whether the detector missed something\n for label in annotations['labels']: \n if label == -1: # This is set after a detection matched this ground truth\n continue\n \n # false negative if we reach this line, since the ground truth object was not found\n all_results['false_negative'] += 1","def demo(sess, net, image_name):\n\n # Load the demo image\n im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\n #im_file = os.path.join('/home/corgi/Lab/label/pos_frame/ACCV/training/000001/',image_name)\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, im)\n timer.toc()\n print (('Detection took {:.3f}s for '\n '{:d} object proposals').format(timer.total_time, boxes.shape[0]))\n\n # Visualize detections for each class\n im = im[:, :, (2, 1, 0)]\n fig, ax = plt.subplots(figsize=(12, 12))\n ax.imshow(im, aspect='equal')\n\n CONF_THRESH = 0.8\n NMS_THRESH = 0.3\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n vis_detections(im, cls, dets, ax, thresh=CONF_THRESH)","def classify_face(im):\r\n faces = get_encoded_faces()\r\n faces_encoded = list(faces.values())\r\n known_face_names = list(faces.keys())\r\n\r\n img = cv2.imread(im, 1)\r\n \"\"\"\r\n Resize optinal \r\n \"\"\"\r\n #img = cv2.resize(img, (0, 0), fx=0.5, fy=0.5)\r\n #img = img[:,:,::-1]\r\n face_locations = face_recognition.face_locations(img)\r\n unknown_face_encodings = face_recognition.face_encodings(img, face_locations)\r\n\r\n face_names = []\r\n for face_encoding in unknown_face_encodings:\r\n # See if the face is a match for the known face(s)\r\n matches = face_recognition.compare_faces(faces_encoded, face_encoding)\r\n name = \"Unknown\"\r\n\r\n # use the known face with the smallest distance to the new face\r\n face_distances = face_recognition.face_distance(faces_encoded, face_encoding)\r\n best_match_index = np.argmin(face_distances)\r\n if matches[best_match_index]:\r\n name = known_face_names[best_match_index]\r\n\r\n face_names.append(name)\r\n\r\n \"\"\"\r\n All the photo lables in the faces foler end with (number) so a simiple .find(\"(\") command takes the () away from\r\n the label leaving us with the full name of the person\r\n\r\n \"\"\"\r\n\r\n result = name.find('(') \r\n fullname = (name[:result])\r\n \"\"\"\r\n If face_recogntion module recognizes a face but that face is not in the faces module then \r\n it will print unknown and we print 12345678 to use it on the start attednace program \r\n\r\n \"\"\"\r\n if (name == \"Unknown\"):\r\n print(\"12345678\")\r\n else:\r\n \"\"\"\r\n f'{len(face_locayion)}-people - will return the number of people in photo taken by Nao'\r\n \"\"\"\r\n print (f'{len(face_locations)}-people')\r\n print (fullname)\r\n print(courseid)\r\n print (lateornot)\r\n c34 = fullname.find(' ')\r\n firstname = (fullname[:c34])\r\n lastname = (fullname[c34:])\r\n \"\"\"\r\n We get all the data courseid , fristname , lastname, datetime1,and late or not and submited on the website \r\n \r\n\r\n \"\"\"\r\n login_data = {\r\n\t 'Course': courseid,\r\n\t 'FirstName': firstname,\r\n\t 'LastName': lastname,\r\n\t 'Date': datetime2,\r\n\t 'Attendance': 'on',\r\n\t 'Late': latev,\r\n\t 'submitbutton': 'Submit'\r\n }\r\n if(fullname == \"Unknow\"):\r\n \tprint(\"I-dont-know-you\")\r\n else:\r\n \r\n with requests.Session() as s:\r\n \turl = \"https://rbattendance.000webhostapp.com/update.php\"\r\n \tr = s.get(url)\r\n \tsoup = BeautifulSoup(r.content, 'html5lib')\r\n \tr = s.post(url, data = login_data)\r\n \t#print(r.content)\r\n \r\n \r\n\r\n\r\n\r\n\r\n \"\"\"\r\n This for loop is reponsible for drawing on the image \r\n \"\"\"\r\n\r\n for (top, right, bottom, left), name in zip(face_locations, face_names):\r\n # Draw a box around the face\r\n cv2.rectangle(img, (left-20, top-20), (right+20, bottom+20), (255, 0, 0), 2)\r\n\r\n # Draw a label with a name below the face\r\n cv2.rectangle(img, (left-20, bottom -15), (right+20, bottom+20), (255, 0, 0), cv2.FILLED)\r\n font = cv2.FONT_HERSHEY_DUPLEX\r\n cv2.putText(img, name, (left -20, bottom + 15), font, 1.0, (255, 255, 255), 2)\r\n\r\n\r\n # Display the resulting image\r\n \r\n \r\n while True:\r\n #cv2.imshow('Video', img)\r\n #if cv2.waitKey(1) & 0xFF == ord('q'):\r\n return face_names","def classify_face(img, HOG_model):\r\n img = pp.resize_image(img, img_input_size)\r\n \r\n # Ensure shape matches exactly\r\n shape_delta = img_input_shape[0] - img.shape[0]\r\n if shape_delta > 0:\r\n new_row = np.random.randint(0,255,[shape_delta,img_input_shape[1],img_input_shape[2]],dtype='uint8')\r\n img = np.vstack([img, new_row])\r\n \r\n elif shape_delta < 0:\r\n img = img[:img_input_shape[0],:,:] \r\n \r\n HOG_img = HOG_extractor(img).flatten()\r\n class_pred = img_classes[HOG_model.predict_proba([HOG_img]).argmax(axis=-1)[0]]\r\n return class_pred","def find_colours(self, img, colour, num_objects=1, ab_dist_thresh=50):\n img_lab = cv2.cvtColor(img,cv2.COLOR_BGR2LAB) #convert to LAB colour space \n img_a = img_lab[:,:,1] #A compononent of image\n img_b = img_lab[:,:,2] #B compononent of image \n des_a = colour[1] #A component of desired colour\n des_b = colour[2] #B component of desired colour\n \n #Compute difference between desired components and actual components\n d_a = img_a - des_a\n d_b = img_b - des_b\n dist_squared = d_a**2 + d_b**2\n \n #Apply threshold\n img_bin = np.uint8(dist_squared<ab_dist_thresh)*255\n \n #do connected components analysis to find centroids of large connected objects\n conn_comp = cv2.connectedComponentsWithStats(img_bin, 8, cv2.CV_32S)\n\n #sort by area, from largest to smallest\n areas = np.int_(conn_comp[2][:,4])\n idx = areas.argsort()\n idx = idx[::-1]\n centroids = np.int_(conn_comp[3])\n centroids = centroids[idx[1:num_objects+1]]\n \n #if more than one object returned, order from left to right\n idx = centroids[:,0].argsort() #sort by x value\n centroids = list(centroids[idx])\n \n #return centroid position and binary image of detected objects\n if len(centroids) == 1:\n return centroids[0], img_bin\n else:\n return centroids, img_bin","def get_classification(self, image, wp = 0):\n\n cv2_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) \n input_image = np.expand_dims(cv2_image, axis=0)\n (boxes, scores, classes) = self.sess.run([self.boxes, self.scores, self.classes], \n feed_dict={self.image_tensor: input_image})\n\n prediction = 4\n min_score_thresh=.6\n sq_boxes = np.squeeze(boxes)\n sq_classes = np.squeeze(classes).astype(np.int32)\n sq_scores = np.squeeze(scores)\n\n for i in range(sq_boxes.shape[0]):\n if sq_scores is None or sq_scores[i] > min_score_thresh:\n prediction = sq_classes[i]\n min_score_thresh = sq_scores[i]\n print(\"Found traffic light: {i:%d prediction:%s pred_score:%.4f}\"%(i, prediction, sq_scores[i]))\n \n if prediction == 1:\n return TrafficLight.RED\n elif prediction == 2:\n return TrafficLight.YELLOW\n elif prediction == 3:\n return TrafficLight.GREEN\n return TrafficLight.UNKNOWN","def _get_class(self, obj):\n\n object_type = obj.object_type\n\n 'Background class'\n object_class = 0\n\n # Don't care classes\n if object_type in ['DontCare', 'Person_sitting'] or obj.truncation > 0.75 or obj.occlusion > 1:\n object_class = 1\n\n # Vehicle classes\n elif object_type in ['Car', 'Van']:\n object_class = 2\n\n # Pedestrian class\n elif object_type in ['Pedestrian']: # TODO: Consider change this with ==\n object_class = 3\n\n # Cyclist class\n elif object_type in ['Cyclist']: # TODO: Consider change this with ==\n object_class = 4\n\n return object_class","def detect_objects(self, image, threshold=0.5, needs_preprocessing=False, temp_path='temp.jpg'):\n if cv2 is None:\n raise Exception(\"OpenCV is not installed.\")\n cv2.imwrite(temp_path, image)\n url = 'http://{}/endpoints/{}/model/{}/v{}/detectobjects'.format(\n self.skil.config.host,\n self.deployment.name,\n self.model.name,\n self.model.version\n )\n\n # TODO: use the official \"detectobject\" client API, once fixed in skil_client\n # print(\">>>> TEST\")\n # resp = self.skil.api.detectobjects(\n # id='foo',\n # needs_preprocessing=False,\n # threshold='0.5',\n # image_file=temp_path,\n # deployment_name=self.model.deployment.name,\n # version_name='default',\n # model_name=self.model.name\n # )\n\n with open(temp_path, 'rb') as data:\n resp = requests.post(\n # TODO: should also have a model \"version\"?\n url=url,\n headers=self.skil.auth_headers,\n files={\n 'file': (temp_path, data, 'image/jpeg')\n },\n data={\n 'id': self.model.id,\n 'needs_preprocessing': 'true' if needs_preprocessing else 'false',\n 'threshold': str(threshold)\n }\n )\n if os.path.isfile(temp_path):\n os.remove(temp_path)\n\n return resp.json()","def vis_detections(color_image, depth_colormap, class_col, dets_col, thresh=0.5):\n\n for cls_ind, class_name in enumerate(class_col):\n dets = dets_col[cls_ind]\n\n inds = np.where(dets[:, -1] >= thresh)[0]\n if len(inds) == 0:\n continue\n\n for i in inds:\n bbox = [int(e) for e in dets[i, :4]]\n score = dets[i, -1]\n \n cv2.rectangle(color_image, (bbox[0], bbox[1]),\n (bbox[2], bbox[3]), (0, 0, 255), 3)\n cv2.rectangle(depth_colormap, (bbox[0], bbox[1]),\n (bbox[2], bbox[3]), (0, 0, 255), 3)\n\n font = cv2.FONT_HERSHEY_SIMPLEX\n color_image = cv2.putText(color_image, '{:s} {:.3f}'.format(class_name, score),\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\n depth_colormap = cv2.putText(depth_colormap, '{:s} {:.3f}'.format(class_name, score),\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\n \n # Stack both images horizontally\n images = np.hstack((color_image, depth_colormap))\n\n # Show images\n cv2.imshow('RealSense', images)","def demo(net, image_name, conf_thres, nms_thres, resDir, bShow=False):\n global CLASSES\n\n # Load the demo image\n im_file = image_name\n im = cv2.imread(im_file)\n fname = os.path.basename(image_name)\n\n # Detect all object classes and regress object bounds\n # timers\n _t = {'im_detect' : Timer(), 'misc' : Timer(), 'save' : Timer()}\n\n _t['im_detect'].tic()\n scores, boxes = im_detect(net, im)\n _t['im_detect'].toc()\n \n \n _t['misc'].tic() \n results = np.zeros((0, 6), dtype=np.float32)\n # Visualize detections for each class\n # for cls_ind, cls in enumerate(CLASSES[1:5]):\n for cls_ind, cls in enumerate(CLASSES[1:]): \n cls_ind += 1 # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n \n # CPU NMS is much faster than GPU NMS when the number of boxes\n # is relative small (e.g., < 10k)\n # TODO(rbg): autotune NMS dispatch\n keep = nms(dets, nms_thres, force_cpu=True)\n dets = dets[keep, :]\n results = np.vstack( (results, np.insert(dets, 0, cls_ind, axis=1)) ) \n _t['misc'].toc() \n \n if bShow:\n plt.figure(1, figsize=(15,10))\n plt.clf()\n axe = plt.gca()\n axe.imshow(im[:,:,(2,1,0)])\n\n clrs = sns.color_palette(\"Set2\", len(CLASSES))\n for det in results:\n cls_ind, box, score = det[0], det[1:5], det[5]\n if score < 0.8: continue\n clr = clrs[int(cls_ind)]\n rect = plt.Rectangle( (box[0], box[1]), box[2]-box[0], box[3]-box[1], fill=False, edgecolor=clr, linewidth=2.5)\n axe.add_patch(rect)\n axe.text(box[0], box[1]-2, '{:.3f}'.format(score), bbox=dict(facecolor=clr, alpha=0.5), fontsize=14, color='white')\n\n axe.axis('off')\n save_name = os.path.basename(im_file)\n plt.savefig('[DEMO]'+save_name, dpi=200) \n\n else:\n _t['save'].tic()\n with open( os.path.join(resDir, fname.split('.')[0] + '.txt'), 'w') as fp: \n for det in results:\n if len(det) == 0: continue \n if det[5] < 0.01: continue\n\n resStr = '{:s} -1 -1 -10 '.format(CLASSES[int(det[0])]) \n resStr += '{:.2f} {:.2f} {:.2f} {:.2f} '.format(det[1],det[2],det[3],det[4]) # x1 y1 x2 y2\n resStr += '-1 -1 -1 -1000 -1000 -1000 -10 {:.4f}\\n'.format(det[5])\n fp.write( resStr ) \n _t['save'].toc()\n\n return _t","def find_objects(img, threshold=.3):\n thresholded_img = np.uint8(img > threshold)\n _, markers = cv2.connectedComponents(thresholded_img)\n object_centers = []\n for ii in range(1, np.max(markers)):\n masked_img = mask_img(img, markers == ii)\n object_index = np.argmax(masked_img)\n object_center = np.unravel_index(object_index, img.shape)\n object_centers.append(object_center)\n return np.array(object_centers)","def get_classification(self, image):\n\n temp = cv2.cvtColor(cv2.GaussianBlur(image,(5,5),0), cv2.COLOR_BGR2HSV)\n\n maskR = cv2.inRange(temp, np.array([0, 195, 240]), np.array([5, 215, 255]))\n maskY = cv2.inRange(temp, np.array([28, 195, 240]), np.array([35, 215, 255]))\n maskG = cv2.inRange(temp, np.array([60, 195, 240]), np.array([67, 215, 255]))\n\n filt_r = cv2.bitwise_and(temp,temp, mask= maskR)\n filt_y = cv2.bitwise_and(temp,temp, mask= maskY)\n filt_g = cv2.bitwise_and(temp,temp, mask= maskG)\n\n # Bitwise-AND mask and original image\n self.debug_im1 = filt_r\n self.debug_im2 = filt_y\n self.debug_im3 = filt_g\n status = TrafficLight.UNKNOWN\n\n if np.sum(maskR>10):\n print('detected red')\n status = TrafficLight.RED\n elif np.sum(maskY>10):\n print('detected yellow')\n status = TrafficLight.YELLOW\n elif np.sum(maskG>10):\n print('detected green')\n status = TrafficLight.GREEN\n\n # self.debug()\n return status","def determineClasses(self, particles):\n\t\tapDisplay.printMsg(\"sorting refineparticledata into classes\")\n\t\tt0 = time.time()\n\t\tclasses={}\n\t\tclass_stats={}\n\t\tquality=numpy.zeros(len(particles))\n\t\tfor partnum in range(len(particles)):\n\t\t\tquality[partnum] = particles[partnum]['quality_factor']\n\t\t\tkey = (\"%.3f_%.3f\"%(particles[partnum]['euler1'], particles[partnum]['euler2']))\n\t\t\tif key not in classes.keys():\n\t\t\t\tclasses[key]={}\n\t\t\t\tclasses[key]['particles']=[]\n\t\t\t\tclasses[key]['euler1'] = particles[partnum]['euler1']\n\t\t\t\tclasses[key]['euler2'] = particles[partnum]['euler2']\n\t\t\t\t#classes have no inplane rotation\n\t\t\t\tclasses[key]['euler3'] = 0.0 #particles[partnum]['euler3']\n\t\t\tclasses[key]['particles'].append(particles[partnum])\n\t\tclass_stats['meanquality']=quality.mean()\n\t\tclass_stats['stdquality']=quality.std()\n\t\tclass_stats['max']=quality.max()\n\t\tclass_stats['min']=quality.min()\n\t\tapDisplay.printMsg(\"sorted %d particles into %d classes\"%(len(particles), len(classes)))\n\t\t### print stats\n\t\tprint \"-- quality factor stats --\"\n\t\tprint (\"mean/std :: \"+str(round(class_stats['meanquality'],2))+\" +/- \"\n\t\t\t+str(round(class_stats['stdquality'],2)))\n\t\tprint (\"min/max :: \"+str(round(class_stats['min'],2))+\" <> \"\n\t\t\t+str(round(class_stats['max'],2)))\n\t\tapDisplay.printMsg(\"finished sorting in \"+apDisplay.timeString(time.time()-t0))\n\t\treturn classes, class_stats","def classif(self, text):\r\n content = self.prizn.tokenize(text)\r\n filec = self.vectorize_content(content)\r\n selected = {}\r\n for klas in self.prizn.klas_tridy:\r\n distance = 0.0\r\n wrdc = 0.0\r\n for wrd in filec:\r\n if wrd in self.prizn.klas_tridy[klas]:\r\n wrdc += 1.0\r\n distance += abs(float(filec[wrd]) - float(self.prizn.klas_tridy[klas][wrd]))\r\n if wrdc > 0:\r\n selected[klas] = float(distance) / float(wrdc)\r\n\r\n max_class = \"\"\r\n for i in range(0, 3):\r\n klas = max(selected, key=lambda k: selected[k])\r\n max_class = max_class + \" ,\" + klas\r\n del selected[klas]\r\n\r\n return max_class","def runClassifier(interpreter, image, threshold):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n count = int(get_output_tensor(interpreter, 3))\n\n results = []\n for i in range(count):\n if scores[i] >= threshold:\n result = {\n \"bounding_box\": boxes[i],\n \"class_id\": classes[i],\n \"score\": scores[i],\n }\n results.append(result)\n return results","def get_object(self, img):\n objectType = 'none'\n colourProb = np.ones((3,)) / 3.0\n distance = 0.0\n angle = 0.0\n self.patternFound = False\n \n #patternFound, corners = self.get_corners(img)\n self.get_corners(img)\n \n if (self.patternFound):\n \n # Determine if the object is horizontal or vertical\n delta_x = abs(self.corners[0,0,0] - self.corners[2,0,0])\n delta_y = abs(self.corners[0,0,1] - self.corners[2,0,1])\n horizontal = (delta_y > delta_x)\n if (horizontal):\n objectType = 'horizontal'\n else:\n objectType = 'vertical'\n \n # Compute distances and angles\n if (horizontal):\n height = ((abs (self.corners [0,0,1] - self.corners [2,0,1]) +\n abs (self.corners [9,0,1] - self.corners [11,0,1])) / 2.0);\n \n patternHeight = (self.patternSize[0]-1.0) * self.patternUnit\n \n else:\n height = (abs (self.corners [0,0,1] - self.corners [9,0,1]) +\n abs (self.corners [2,0,1] - self.corners [11,0,1])) / 2.0;\n \n patternHeight = (self.patternSize[1]-1.0) * self.patternUnit\n \n #distance = 1.0 / (0.0001 * height);\n distance = self.intrinsic_matrix[1,1] * patternHeight / (height * 10.0) \n\n center = (self.corners [0,0,0] + self.corners [2,0,0] +\n self.corners [9,0,0] + self.corners [11,0,0]) / 4.0;\n \n #angle = 0.0018 * center - 0.6425;\n #angle *= -1.0;\n angle = -np.arctan2(center - self.intrinsic_matrix[0,2], self.intrinsic_matrix[0,0])\n \n \n #### Classify object by colour\n \n # Extract rectangle corners\n points = np.array(\n [self.corners [0],\n self.corners [2],\n self.corners [9],\n self.corners [11]]\n )\n \n points.shape = (4,2)\n points = np.int32(points)\n\n # Compute region of interest\n mask = np.zeros((self.imageSize[1], self.imageSize[0]), dtype =np.uint8) \n cv2.fillConvexPoly (mask, points, (255, 255, 255)) \n \n # Compute mean colour inside region of interest\n mean_colour = cv2.mean(img, mask);\n \n red = mean_colour[2];\n green = mean_colour[1];\n blue = mean_colour[0];\n sum = red + green + blue;\n\n colourProb[0] = red / sum;\n colourProb[1] = green / sum;\n colourProb[2] = blue / sum;\n \n \n return objectType, distance, angle, colourProb","def checkout_findings(pseudo, conf, show=True):\n ### Create images with label names\n class_label_img = []\n# font_path = '/usr/share/fonts/truetype/ubuntu/UbuntuMono-B.ttf'\n font_path = '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf'\n img_width = 512\n font_size = int(img_width*0.14) #hypkva 15\n letters_per_line = 12 #hypkva 13\n\n for i in range(conf[\"num_classes\"]):\n img = Image.new('RGB', (img_width, img_width), color = (0, 0, 0))\n fnt = ImageFont.truetype(font_path, font_size)\n d = ImageDraw.Draw(img)\n if (len(conf[\"class_names\"][i])>letters_per_line):\n text = textwrap.fill(conf[\"class_names\"][i], width=letters_per_line)\n else:\n text = conf[\"class_names\"][i]\n linebreaks = text.count('\\n')\n d.text((1,(img_width//2.2)-linebreaks*img_width*0.1), text, font=fnt, fill=(255, 255, 255))\n\n class_label_img.append(img)\n \n ### Create a list with 6 samples per class\n # black image\n img_black = Image.new('RGB', (conf[\"img_shape\"][0], conf[\"img_shape\"][1]), color = (0, 0, 0))\n \n lab_arr = np.asarray(pseudo[\"lab_list\"], dtype=np.uint8)\n class_examples = []\n class_preds = []\n for class_idx in range(conf[\"num_classes\"]):\n curr_class_examples = []\n curr_class_preds = []\n\n indekser = np.where(lab_arr==class_idx)[0]\n for i in range(6):\n # get 6 finding images from class_idx-class\n # no image - index out of bounds\n if not indekser.size > i:\n curr_class_examples.append(img_black)\n curr_class_preds.append(0)\n # found image\n else:\n fn = pseudo[\"name_list\"][indekser[i]]\n img = fn2img(fn, conf[\"unlab_dir\"], img_width)\n \n curr_class_examples.append(img)\n curr_class_preds.append(pseudo[\"pred_list\"][indekser[i]])\n\n class_examples.append(curr_class_examples)\n class_preds.append(curr_class_preds)\n\n assert (len(conf[\"class_names\"])==len(class_examples)), 'must be same length'\n \n ### Display the predicted images in each class\n # settings\n nrows, ncols = conf[\"num_classes\"], 7 # array of sub-plots\n figsize = [ncols*3, conf[\"num_classes\"]*3] # figure size, inches\n\n # create figure (fig), and array of axes (ax)\n fig, ax = plt.subplots(nrows=nrows, ncols=ncols, \n figsize=figsize, frameon=False, facecolor='white')\n\n # plot simple raster image on each sub-plot\n for i, axi in enumerate(ax.flat):\n # i runs from 0 to (nrows*ncols-1)\n # axi is equivalent with ax[rowid][colid]\n rowid = i // ncols\n colid = i % ncols\n\n if colid == 0:\n img = class_label_img[rowid]\n else:\n pred = class_preds[rowid][colid-1]\n title = \"conf: \"+str(round(pred, 3))\n if pred: axi.set_title(title)\n img = class_examples[rowid][colid-1]\n \n axi.imshow(img)\n axi.set_axis_off()\n\n plt.axis('off')\n plt.tight_layout(True)\n plt.savefig(\"{}/checkout-all.pdf\".format(conf[\"log_dir\"]), format='pdf')\n if show:\n plt.show()\n else:\n plt.close()","def classify_image_probavec(image, model, image_box=None):\n images_list = []\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\n # box argument clips image to (x1, y1, x2, y2)\n image = np.array(image)\n images_list.append(image)\n \n return model.predict(np.array(images_list))","def on_object(self, image, objects):\n for obj in objects:\n if self.is_object_recognition_appropriate(obj.name):\n self.say(\"I see a {}\".format(obj.name))","def detect_all_objects(gray, haar_file, params, verbose=False):\n # Not the most performant to load haar_cascade for each image when params aren't changing...\n haar_cascade = cv.CascadeClassifier(haar_file)\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\n if verbose:\n print(f\"# of Objects Detected = {len(detected_objects)}\")\n return detected_objects","def compute_precision_recall_bbox(per_image_detections, per_image_gts, num_gt_classes,\n matching_iou_threshold=0.5):\n per_image_eval = per_image_evaluation.PerImageEvaluation(\n num_groundtruth_classes=num_gt_classes,\n matching_iou_threshold=matching_iou_threshold,\n nms_iou_threshold=1.0,\n nms_max_output_boxes=10000\n )\n\n print('Running per-object analysis...')\n\n detection_tp_fp = defaultdict(list) # key is the category; in each list, 1 is tp, 0 is fp\n detection_scores = defaultdict(list)\n num_total_gt = defaultdict(int)\n\n for image_id, dets in tqdm(per_image_detections.items()):\n\n detected_boxes = np.array(dets['boxes'], dtype=np.float32)\n detected_scores = np.array(dets['scores'], dtype=np.float32)\n # labels input to compute_object_detection_metrics() needs to start at 0, not 1\n detected_labels = np.array(dets['labels'], dtype=np.int) - 1 # start at 0\n # num_detections = len(dets['boxes'])\n\n gts = per_image_gts[image_id]\n gt_boxes = np.array(gts['gt_boxes'], dtype=np.float32)\n gt_labels = np.array(gts['gt_labels'], dtype=np.int) - 1 # start at 0\n num_gts = len(gts['gt_boxes'])\n\n groundtruth_is_difficult_list = np.zeros(num_gts, dtype=bool) # place holders - we don't have these\n groundtruth_is_group_of_list = np.zeros(num_gts, dtype=bool)\n\n # to prevent 'Invalid dimensions for box data.' error\n if num_gts == 0:\n # this box will not match any detections\n gt_boxes = np.array([[0, 0, 0, 0]], dtype=np.float32)\n\n scores, tp_fp_labels, is_class_correctly_detected_in_image = (\n per_image_eval.compute_object_detection_metrics(\n detected_boxes=detected_boxes,\n detected_scores=detected_scores,\n detected_class_labels=detected_labels,\n groundtruth_boxes=gt_boxes,\n groundtruth_class_labels=gt_labels,\n groundtruth_is_difficult_list=groundtruth_is_difficult_list,\n groundtruth_is_group_of_list=groundtruth_is_group_of_list\n )\n )\n\n for i, tp_fp_labels_cat in enumerate(tp_fp_labels):\n assert sum(tp_fp_labels_cat) <= sum(gt_labels == i) # true positives < gt of that category\n cat = i + 1 # categories start at 1\n detection_tp_fp[cat].append(tp_fp_labels_cat)\n detection_scores[cat].append(scores[i])\n num_total_gt[cat] += sum(gt_labels == i) # gt_labels start at 0\n\n all_scores = []\n all_tp_fp = []\n\n print('Computing precision recall for each category...')\n per_cat_metrics = {}\n for i in range(num_gt_classes):\n cat = i + 1\n scores_cat = np.concatenate(detection_scores[cat])\n tp_fp_cat = np.concatenate(detection_tp_fp[cat]).astype(np.bool)\n all_scores.append(scores_cat)\n all_tp_fp.append(tp_fp_cat)\n\n precision, recall = metrics.compute_precision_recall(\n scores_cat, tp_fp_cat, num_total_gt[cat]\n )\n average_precision = metrics.compute_average_precision(precision, recall)\n\n per_cat_metrics[cat] = {\n 'category': cat,\n 'precision': precision,\n 'recall': recall,\n 'average_precision': average_precision,\n 'scores': scores_cat,\n 'tp_fp': tp_fp_cat,\n 'num_gt': num_total_gt[cat]\n }\n print('Number of ground truth in category {} is {}'.format(cat, num_total_gt[cat]))\n\n # compute one-class precision/recall/average precision (if every box is just of an object class)\n all_scores = np.concatenate(all_scores)\n all_tp_fp = np.concatenate(all_tp_fp)\n overall_gt_count = sum(num_total_gt.values())\n\n one_class_prec, one_class_recall = metrics.compute_precision_recall(\n all_scores, all_tp_fp, overall_gt_count\n )\n one_class_average_precision = metrics.compute_average_precision(one_class_prec, one_class_recall)\n\n per_cat_metrics['one_class'] = {\n 'category': 'one_class',\n 'precision': one_class_prec,\n 'recall': one_class_recall,\n 'average_precision': one_class_average_precision,\n 'scores': all_scores,\n 'tp_fp': all_tp_fp,\n 'num_gt': overall_gt_count\n }\n\n return per_cat_metrics","def classify_image(img_pil):\n results = tpu.ClassifyWithImage(img_pil, top_k=1)\n if len(results) == 0:\n return None, None\n i, score = results[0]\n label = labels[i]\n # print(label + \": \" + str(score))\n return label, score","def vis_detections(im, class_name, dets, thresh=0.5):\n global CHECK\n global CLASS_NAME\n global INDS\n global RES\n inds = np.where(dets[:, -1] >= thresh)[0]\n if len(inds) == 0:\n return\n bbox = dets[inds[0], :4]\n score = dets[inds[0], -1]\n if len(inds) > 1:\n score = -1\n for i in inds:\n temp = dets[i, -1]\n if (temp > score):\n score = temp\n bbox = dets[i, :4]\n if score <= MAX_SCORE[0]:\n return\n else:\n CHECK = 1\n MAX_SCORE[0] = score\n CLASS_NAME = class_name\n # im = im[:, :, (2, 1, 0)]\n # fig, ax = plt.subplots()\n # ax.imshow(im, aspect='equal')\n # ax.add_patch(\n # plt.Rectangle((bbox[0], bbox[1]),\n # bbox[2] - bbox[0],\n # bbox[3] - bbox[1], fill=False,\n # edgecolor='red', linewidth=3.5)\n # )\n # ax.text(bbox[0], bbox[1] - 2,\n # '{:s} {:.3f}'.format(class_name, score),\n # bbox=dict(facecolor='blue', alpha=0.5),\n # fontsize=10, color='white')\n # ax.set_title(('{} detections with '\n # 'p({} | box) >= {:.1f}').format(class_name, class_name,\n # thresh),\n # fontsize=10)\n # plt.axis('off')\n # plt.tight_layout()\n # plt.draw()","def vis_detections(im, class_name, dets, thresh=0.8):\n for i in range(np.minimum(10, dets.shape[0])):\n bbox = tuple(int(np.round(x)) for x in dets[i, :4])\n score = dets[i, -1]\n if score > thresh:\n cv2.rectangle(im, bbox[0:2], bbox[2:4], (0, 204, 0), 2)\n cv2.putText(im, '%s: %.3f' % (class_name, score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_PLAIN,\n 1.0, (0, 0, 255), thickness=1)\n return im","def draw_detections(self, img, yolo_results):\n\n _, height, _ = img.shape\n for yolo_result in yolo_results:\n class_index = yolo_result.class_index\n obj_name = yolo_result.obj_name\n x = yolo_result.x_min\n y = yolo_result.y_min\n w = yolo_result.width\n h = yolo_result.height\n\n offset = class_index * 123457 % self.meta.classes\n\n red = self._get_color(2, offset, self.meta.classes)\n green = self._get_color(1, offset, self.meta.classes)\n blue = self._get_color(0, offset, self.meta.classes)\n box_width = int(height * 0.006)\n cv2.rectangle(img, (int(x), int(y)), (int(x+w)+1, int(y+h)+1), (red, green, blue), box_width)\n cv2.putText(img, obj_name, (int(x) -1, int(y) -1), cv2.FONT_HERSHEY_PLAIN, 2, (red, green, blue), 2)\n\n return img","def classifier():\n\tprint(\"Classifying\")\n\t#initialize important variables\n\tminConfidence = 0.5\n\tthresholdValue = 0.3\n\t\n\t\"\"\"\n\tfile = request.files#['image']\n\tfile.save(\"./classifier_image.jpg\")\n\tframe = cv2.imread(\"./classifier_image.jpg\")\n\t\"\"\"\n\tfile = request.json\n\tframe = np.array(file[\"Frame\"], dtype = \"uint8\") \n\n\t#file = request.files['image']\n\t#file.save(\"./classifier_image.jpg\")\n\t#frame = cv2.imread(\"./classifier_image.jpg\")\n\t#file = request.json\n\t#frame = np.array(file[\"contour\"], dtype=\"uint8\")\n\t\n\t#Get Image dimensions\n\timage = cv2.copyMakeBorder(frame, 30, 30, 30, 30, cv2.BORDER_CONSTANT, value=255)\n\t(H, W) = image.shape[:2]\n\t\n\t#Get the output layers parameters\n\tln = net.getLayerNames()\n\tln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]\n\t\n\t#Create a blob to do a forward pass\n\tblob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False)\n\tnet.setInput(blob)\n\t#print(H, W)\n\tlayerOutputs = net.forward(ln)\n\tprint(type(net))\n\tboxes = []\n\tconfidences = []\n\tclassIDs = []\n\tfor output in layerOutputs:\n\t\tprint(\"detecting\")\n\t\t#loop over each detection\n\t\tfor detection in output:\n\t\t\t# extract the class ID and confidence (i.e., probability) of\n\t\t\t# the current object detection\n\t\t\tscores = detection[5:]\n\t\t\tclassID = np.argmax(scores)\n\t\t\tconfidence = scores[classID]\n\n\t\t\t# filter out weak predictions by ensuring the detected\n\t\t\t# probability is greater than the minimum probability\n\t\t\tif confidence > minConfidence:\n\t\t\t\t# scale the bounding box coordinates back relative to the\n\t\t\t\t# size of the image, keeping in mind that YOLO actually\n\t\t\t\t# returns the center (x, y)-coordinates of the bounding\n\t\t\t\t# box followed by the boxes' width and height\n\t\t\t\tbox = detection[0:4] * np.array([W, H, W, H])\n\t\t\t\t(centerX, centerY, width, height) = box.astype(\"int\")\n\n\t\t\t\t# use the center (x, y)-coordinates to derive the top and\n\t\t\t\t# and left corner of the bounding box\n\t\t\t\tx = int(centerX - (width / 2))\n\t\t\t\ty = int(centerY - (height / 2))\n\n\t\t\t\t# update our list of bounding box coordinates, confidences,\n\t\t\t\t# and class IDs\n\t\t\t\tboxes.append([x, y, int(width), int(height)])\n\t\t\t\tconfidences.append(float(confidence))\n\t\t\t\tclassIDs.append(classID)\n\n\t# apply non-maxima suppression to suppress weak, overlapping bounding\n\t# boxes\n\tidxs = cv2.dnn.NMSBoxes(boxes, confidences, minConfidence, thresholdValue)\n\n\t# ensure at least one detection exists\n\tif len(idxs) > 0:\n\t\toutput = json.load(open(outputFile))\n\t\t# loop over the indexes we are keeping\n\t\tfor i in idxs.flatten():\n\t\t\t# extract the bounding box coordinates\n\t\t\t(x, y) = (boxes[i][0], boxes[i][1])\n\t\t\t(w, h) = (boxes[i][2], boxes[i][3])\n\n\t\t\tprint(LABELS[classIDs[i]], output[LABELS[classIDs[i]]]+1, confidences[i])\n\t\t\toutput[LABELS[classIDs[i]]]+=1\n\t\t\n\t\tjson.dump(output, open(outputFile, \"w\"))\n\t\treturn LABELS[classIDs[i]]\n\telse:\n\t\treturn Response(status=200)","def im_detect(net, target_data,im_data, im_info, features_given=True):\n\n cls_prob, rois = net(target_data, im_data, im_info,\n features_given=features_given)\n scores = cls_prob.data.cpu().numpy()[0,:,:]\n zs = np.zeros((scores.size, 1))\n scores = np.concatenate((zs,scores),1)\n boxes = rois.data.cpu().numpy()[0,:, :]\n\n return scores, boxes","def classProbs(observation, tree, classes):\n res = classify(observation, tree) #res = results\n total = sum(res.values())\n probs = []\n for c in classes:\n if c in res.keys():\n probs.append(float(res[c])/total)\n else:\n probs.append(0)\n return probs","def postprocess(self, prediction_dict, true_image_shapes, **params):\n object_center_prob = tf.nn.sigmoid(prediction_dict[OBJECT_CENTER][-1])\n\n if true_image_shapes is None:\n # If true_image_shapes is not provided, we assume the whole image is valid\n # and infer the true_image_shapes from the object_center_prob shape.\n batch_size, strided_height, strided_width, _ = _get_shape(\n object_center_prob, 4)\n true_image_shapes = tf.stack(\n [strided_height * self._stride, strided_width * self._stride,\n tf.constant(len(self._feature_extractor._channel_means))]) # pylint: disable=protected-access\n true_image_shapes = tf.stack([true_image_shapes] * batch_size, axis=0)\n else:\n # Mask object centers by true_image_shape. [batch, h, w, 1]\n object_center_mask = mask_from_true_image_shape(\n _get_shape(object_center_prob, 4), true_image_shapes)\n object_center_prob *= object_center_mask\n\n # Get x, y and channel indices corresponding to the top indices in the class\n # center predictions.\n detection_scores, y_indices, x_indices, channel_indices = (\n top_k_feature_map_locations(\n object_center_prob,\n max_pool_kernel_size=self._center_params.peak_max_pool_kernel_size,\n k=self._center_params.max_box_predictions))\n multiclass_scores = tf.gather_nd(\n object_center_prob, tf.stack([y_indices, x_indices], -1), batch_dims=1)\n num_detections = tf.reduce_sum(\n tf.cast(detection_scores > 0, tf.int32), axis=1)\n postprocess_dict = {\n fields.DetectionResultFields.detection_scores: detection_scores,\n fields.DetectionResultFields.detection_multiclass_scores:\n multiclass_scores,\n fields.DetectionResultFields.detection_classes: channel_indices,\n fields.DetectionResultFields.num_detections: num_detections,\n }\n\n if self._output_prediction_dict:\n postprocess_dict.update(prediction_dict)\n postprocess_dict['true_image_shapes'] = true_image_shapes\n\n boxes_strided = None\n if self._od_params:\n boxes_strided = (\n prediction_tensors_to_boxes(y_indices, x_indices,\n prediction_dict[BOX_SCALE][-1],\n prediction_dict[BOX_OFFSET][-1]))\n\n boxes = convert_strided_predictions_to_normalized_boxes(\n boxes_strided, self._stride, true_image_shapes)\n\n postprocess_dict.update({\n fields.DetectionResultFields.detection_boxes: boxes,\n 'detection_boxes_strided': boxes_strided,\n })\n\n if self._kp_params_dict:\n # If the model is trained to predict only one class of object and its\n # keypoint, we fall back to a simpler postprocessing function which uses\n # the ops that are supported by tf.lite on GPU.\n clip_keypoints = self._should_clip_keypoints()\n if len(self._kp_params_dict) == 1 and self._num_classes == 1:\n task_name, kp_params = next(iter(self._kp_params_dict.items()))\n keypoint_depths = None\n if kp_params.argmax_postprocessing:\n keypoints, keypoint_scores = (\n prediction_to_keypoints_argmax(\n prediction_dict,\n object_y_indices=y_indices,\n object_x_indices=x_indices,\n boxes=boxes_strided,\n task_name=task_name,\n kp_params=kp_params))\n else:\n (keypoints, keypoint_scores,\n keypoint_depths) = self._postprocess_keypoints_single_class(\n prediction_dict, channel_indices, y_indices, x_indices,\n boxes_strided, num_detections)\n keypoints, keypoint_scores = (\n convert_strided_predictions_to_normalized_keypoints(\n keypoints, keypoint_scores, self._stride, true_image_shapes,\n clip_out_of_frame_keypoints=clip_keypoints))\n if keypoint_depths is not None:\n postprocess_dict.update({\n fields.DetectionResultFields.detection_keypoint_depths:\n keypoint_depths\n })\n else:\n # Multi-class keypoint estimation task does not support depth\n # estimation.\n assert all([\n not kp_dict.predict_depth\n for kp_dict in self._kp_params_dict.values()\n ])\n keypoints, keypoint_scores = self._postprocess_keypoints_multi_class(\n prediction_dict, channel_indices, y_indices, x_indices,\n boxes_strided, num_detections)\n keypoints, keypoint_scores = (\n convert_strided_predictions_to_normalized_keypoints(\n keypoints, keypoint_scores, self._stride, true_image_shapes,\n clip_out_of_frame_keypoints=clip_keypoints))\n\n postprocess_dict.update({\n fields.DetectionResultFields.detection_keypoints: keypoints,\n fields.DetectionResultFields.detection_keypoint_scores:\n keypoint_scores\n })\n if self._od_params is None:\n # Still output the box prediction by enclosing the keypoints for\n # evaluation purpose.\n boxes = keypoint_ops.keypoints_to_enclosing_bounding_boxes(\n keypoints, keypoints_axis=2)\n postprocess_dict.update({\n fields.DetectionResultFields.detection_boxes: boxes,\n })\n\n if self._mask_params:\n masks = tf.nn.sigmoid(prediction_dict[SEGMENTATION_HEATMAP][-1])\n densepose_part_heatmap, densepose_surface_coords = None, None\n densepose_class_index = 0\n if self._densepose_params:\n densepose_part_heatmap = prediction_dict[DENSEPOSE_HEATMAP][-1]\n densepose_surface_coords = prediction_dict[DENSEPOSE_REGRESSION][-1]\n densepose_class_index = self._densepose_params.class_id\n instance_masks, surface_coords = (\n convert_strided_predictions_to_instance_masks(\n boxes, channel_indices, masks, true_image_shapes,\n densepose_part_heatmap, densepose_surface_coords,\n stride=self._stride, mask_height=self._mask_params.mask_height,\n mask_width=self._mask_params.mask_width,\n score_threshold=self._mask_params.score_threshold,\n densepose_class_index=densepose_class_index))\n postprocess_dict[\n fields.DetectionResultFields.detection_masks] = instance_masks\n if self._densepose_params:\n postprocess_dict[\n fields.DetectionResultFields.detection_surface_coords] = (\n surface_coords)\n\n if self._track_params:\n embeddings = self._postprocess_embeddings(prediction_dict,\n y_indices, x_indices)\n postprocess_dict.update({\n fields.DetectionResultFields.detection_embeddings: embeddings\n })\n\n if self._temporal_offset_params:\n offsets = prediction_tensors_to_temporal_offsets(\n y_indices, x_indices,\n prediction_dict[TEMPORAL_OFFSET][-1])\n postprocess_dict[fields.DetectionResultFields.detection_offsets] = offsets\n\n if self._non_max_suppression_fn:\n boxes = tf.expand_dims(\n postprocess_dict.pop(fields.DetectionResultFields.detection_boxes),\n axis=-2)\n multiclass_scores = postprocess_dict[\n fields.DetectionResultFields.detection_multiclass_scores]\n num_classes = tf.shape(multiclass_scores)[2]\n class_mask = tf.cast(\n tf.one_hot(\n postprocess_dict[fields.DetectionResultFields.detection_classes],\n depth=num_classes), tf.bool)\n # Surpress the scores of those unselected classes to be zeros. Otherwise,\n # the downstream NMS ops might be confused and introduce issues.\n multiclass_scores = tf.where(\n class_mask, multiclass_scores, tf.zeros_like(multiclass_scores))\n num_valid_boxes = postprocess_dict.pop(\n fields.DetectionResultFields.num_detections)\n # Remove scores and classes as NMS will compute these form multiclass\n # scores.\n postprocess_dict.pop(fields.DetectionResultFields.detection_scores)\n postprocess_dict.pop(fields.DetectionResultFields.detection_classes)\n (nmsed_boxes, nmsed_scores, nmsed_classes, _, nmsed_additional_fields,\n num_detections) = self._non_max_suppression_fn(\n boxes,\n multiclass_scores,\n additional_fields=postprocess_dict,\n num_valid_boxes=num_valid_boxes)\n postprocess_dict = nmsed_additional_fields\n postprocess_dict[\n fields.DetectionResultFields.detection_boxes] = nmsed_boxes\n postprocess_dict[\n fields.DetectionResultFields.detection_scores] = nmsed_scores\n postprocess_dict[\n fields.DetectionResultFields.detection_classes] = nmsed_classes\n postprocess_dict[\n fields.DetectionResultFields.num_detections] = num_detections\n postprocess_dict.update(nmsed_additional_fields)\n\n # Perform the rescoring once the NMS is applied to make sure the rescored\n # scores won't be washed out by the NMS function.\n if self._kp_params_dict:\n channel_indices = postprocess_dict[\n fields.DetectionResultFields.detection_classes]\n detection_scores = postprocess_dict[\n fields.DetectionResultFields.detection_scores]\n keypoint_scores = postprocess_dict[\n fields.DetectionResultFields.detection_keypoint_scores]\n # Update instance scores based on keypoints.\n scores = self._rescore_instances(\n channel_indices, detection_scores, keypoint_scores)\n postprocess_dict.update({\n fields.DetectionResultFields.detection_scores: scores,\n })\n return postprocess_dict","def inference(self, img, probe_roi=None, threshold=0.75):\n device = self.cls_score.weight.device\n processed_img, scale = img_preprocessing(img)\n # [C, H, W] -> [N, C, H, W]\n processed_img = torch.from_numpy(processed_img).unsqueeze(0).to(device)\n # img_info: (height, width, scale)\n img_info = torch.Tensor([processed_img.shape[2], processed_img.shape[3], scale]).to(device)\n if probe_roi is not None:\n probe_roi = torch.from_numpy(probe_roi).float().view(1, 4)\n probe_roi *= scale\n # Add an extra 0, which means the probe_roi is from the first image in the batch\n probe_roi = torch.cat((torch.zeros(1, 1), probe_roi.float()), dim=1).to(device)\n\n with torch.no_grad():\n proposals, probs, proposal_deltas, features, _, _, _, _, _ = self.forward(\n processed_img, img_info, None, probe_roi\n )\n\n if probe_roi is not None:\n return features\n\n # Unscale proposals back to raw image space\n proposals = proposals[:, 1:5] / scale\n # Unnormalize proposal deltas\n num_classes = proposal_deltas.shape[1] // 4\n stds = torch.Tensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).repeat(num_classes).to(device)\n means = torch.Tensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).repeat(num_classes).to(device)\n proposal_deltas = proposal_deltas * stds + means\n # Apply proposal regression deltas\n boxes = bbox_transform_inv(proposals, proposal_deltas)\n boxes = clip_boxes(boxes, img.shape)\n\n # Remove those boxes with scores below the threshold\n j = 1 # Only consider foreground class\n keep = torch.nonzero(probs[:, j] > threshold, as_tuple=False)[:, 0]\n boxes = boxes[keep, j * 4 : (j + 1) * 4]\n probs = probs[keep, j]\n features = features[keep]\n\n # Remove redundant boxes with NMS\n detections = torch.cat((boxes, probs.unsqueeze(1)), dim=1)\n keep = nms(boxes, probs, cfg.TEST.NMS)\n detections = detections[keep]\n features = features[keep]\n\n return detections, features","def classify_image(image, model, image_box=None):\n images_list = []\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\n # box argument clips image to (x1, y1, x2, y2)\n image = np.array(image)\n images_list.append(image)\n \n return [np.argmax(model.predict(np.array(images_list)))]","def detect_from_image(self, imageMatrix):\n image = imageMatrix #TODO\n self.imageHeight, self.imageWidth, _ = imageMatrix.shape\n # Resize the image as required by network\n # Make image shape 1x448x448x3\n # Normalize the image values between -1 and 1\n imageMatrix = np.expand_dims(\n np.asarray(\n cv2.cvtColor(\n cv2.resize(\n imageMatrix, (448, 448)\n ), cv2.COLOR_BGR2RGB\n ), dtype='float32')/255.*2. - 1., axis=0)\n # Run image through network and get its output\n netOutput = self.sess.run(self.fc3, feed_dict={self.x: imageMatrix})\n # Figure out the object classes and bounding boxes from the\n # network output\n self.result = self.interpret_output(netOutput)\n # Make an annotated image with the classes and bounding boxes\n return self.annotate_image(image, self.result)","def detect_objects(self, predicted_locs, predicted_scores, min_score, max_overlap, top_k):\n batch_size = predicted_locs.size(0)\n n_priors = self.priors_cxcy.size(0)\n predicted_scores = F.softmax(predicted_scores, dim=2) # (N, 8732, n_classes)\n\n # Lists to store final predicted boxes, labels, and scores for all images\n all_images_boxes = list()\n all_images_labels = list()\n all_images_scores = list()\n\n assert n_priors == predicted_locs.size(1) == predicted_scores.size(1)\n\n for i in range(batch_size):\n # Decode object coordinates from the form we regressed predicted boxes to\n decoded_locs = cxcy_to_xy(\n gcxgcy_to_cxcy(predicted_locs[i], self.priors_cxcy)) # (8732, 4), these are fractional pt. coordinates\n\n # Lists to store boxes and scores for this image\n image_boxes = list()\n image_labels = list()\n image_scores = list()\n\n max_scores, best_label = predicted_scores[i].max(dim=1) # (8732)\n\n # Check for each class\n for c in range(1, self.n_classes):\n # Keep only predicted boxes and scores where scores for this class are above the minimum score\n class_scores = predicted_scores[i][:, c] # (8732)\n score_above_min_score = class_scores > min_score # torch.uint8 (byte) tensor, for indexing\n n_above_min_score = score_above_min_score.sum().item()\n if n_above_min_score == 0:\n continue\n class_scores = class_scores[score_above_min_score] # (n_qualified), n_min_score <= 8732\n class_decoded_locs = decoded_locs[score_above_min_score] # (n_qualified, 4)\n\n # Sort predicted boxes and scores by scores\n class_scores, sort_ind = class_scores.sort(dim=0, descending=True) # (n_qualified), (n_min_score)\n class_decoded_locs = class_decoded_locs[sort_ind] # (n_min_score, 4)\n\n # Find the overlap between predicted boxes\n overlap = find_jaccard_overlap(class_decoded_locs, class_decoded_locs) # (n_qualified, n_min_score)\n\n #-- Non-Maximum Suppression (NMS)\n # A torch.uint8 (byte) tensor to keep track of which predicted boxes to suppress\n # 1 implies suppress, 0 implies don't suppress\n suppress = torch.zeros((n_above_min_score), dtype=torch.uint8).to(self.device) # (n_qualified)\n\n # Consider each box in order of decreasing scores\n for box in range(class_decoded_locs.size(0)):\n # If this box is already marked for suppression\n if suppress[box] == 1:\n continue\n\n # Suppress boxes whose overlaps (with this box) are greater than maximum overlap\n # Find such boxes and update suppress indices\n suppress = suppress.bool() | (overlap[box] > max_overlap).bool()\n # The max operation retains previously suppressed boxes, like an 'OR' operation\n\n # Don't suppress this box, even though it has an overlap of 1 with itself\n suppress[box] = 0\n\n # Store only unsuppressed boxes for this class\n image_boxes.append(class_decoded_locs[~suppress])\n image_labels.append(\n torch.LongTensor(\n (~suppress).sum().item() * [c]).to(self.device)\n )\n image_scores.append(class_scores[~suppress])\n\n # image_boxes.append(class_decoded_locs[1 - suppress])\n # image_labels.append(torch.LongTensor((1 - suppress).sum().item() * [c]).to(self.device))\n # image_scores.append(class_scores[1 - suppress])\n\n # If no object in any class is found, store a placeholder for 'background'\n if len(image_boxes) == 0:\n image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(self.device))\n image_labels.append(torch.LongTensor([0]).to(self.device))\n image_scores.append(torch.FloatTensor([0.]).to(self.device))\n\n # Concatenate into single tensors\n image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4)\n image_labels = torch.cat(image_labels, dim=0) # (n_objects)\n image_scores = torch.cat(image_scores, dim=0) # (n_objects)\n n_objects = image_scores.size(0)\n\n # Keep only the top k objects\n if n_objects > top_k:\n image_scores, sort_ind = image_scores.sort(dim=0, descending=True)\n image_scores = image_scores[:top_k] # (top_k)\n image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4)\n image_labels = image_labels[sort_ind][:top_k] # (top_k)\n\n # Append to lists that store predicted boxes and scores for all images\n all_images_boxes.append(image_boxes)\n all_images_labels.append(image_labels)\n all_images_scores.append(image_scores)\n\n return all_images_boxes, all_images_labels, all_images_scores # lists of length batch_size","def detect_fn(image):\n\n image, shapes = model.preprocess(image)\n prediction_dict = model.predict(image, shapes)\n detections = model.postprocess(prediction_dict, shapes)\n\n return detections, prediction_dict, tf.reshape(shapes, [-1])","def im_detect(net, im, boxes):\n blobs, unused_im_scale_factors = _get_blobs(im, boxes)\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\n # (some distinct image ROIs get mapped to the same feature ROI).\n # Here, we identify duplicate feature ROIs, so we only compute features\n # on the unique subset.\n for i in range(len(blobs['data'])):\n if cfg.DEDUP_BOXES > 0:\n v = np.array([1, 1e3, 1e6, 1e9, 1e12])\n hashes = np.round(blobs['rois'][i] * cfg.DEDUP_BOXES).dot(v)\n _, index, inv_index = np.unique(hashes, return_index=True,\n return_inverse=True)\n blobs['rois'][i] = blobs['rois'][i][index, :]\n boxes_tmp = boxes[index, :].copy()\n else:\n boxes_tmp = boxes.copy()\n t_data = blobs['data'][i].astype(np.float32, copy=False)\n #t_data = t_data.reshape((1, t_data.shape[0], t_data.shape[1], t_data.shape[2], t_data.shape[3]))\n data_height, data_width = t_data.shape[1], t_data.shape[2]\n im_data = torch.FloatTensor(t_data).cuda()\n im_data = im_data.permute(0, 3, 1, 2).contiguous() #.view(3, data_height, data_width)\n LIM = 2000 # split ROIs due to memory issue\n if cfg.TEST.USE_FLIPPED :\n blobs['data'][i] = blobs['data'][i][:, :, ::-1, :]\n width = blobs['data'][i].shape[2]\n t_data = blobs['data'][i].astype(np.float32, copy=False)\n data_height, data_width = t_data.shape[1], t_data.shape[2]\n #im_data = torch.FloatTensor(t_data).cuda()\n im_data_flip = torch.from_numpy(t_data.copy()).cuda()\n im_data_flip = im_data_flip.permute(0, 3, 1, 2).contiguous()#.view(3, data_height, data_width)\n #im_data = im_data[...,::-1]\n for j in range (int(np.ceil(blobs['rois'][i].shape[0] / LIM))) :\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\n im_rois = torch.FloatTensor(t_rois).cuda()\n ic_prob, ic_prob1, ic_prob2 = net(im_data, im_rois)\n scores_tmp = ic_prob + ic_prob1 + ic_prob2\n pred_boxes_small = np.tile(boxes_tmp[j*LIM : (j+1)*LIM], (1, scores_tmp.shape[2]))\n\n if cfg.TEST.USE_FLIPPED:\n #pdb.set_trace()\n oldx1 = blobs['rois'][i][j*LIM:(j+1)*LIM, 1].copy()\n oldx2 = blobs['rois'][i][j*LIM:(j+1)*LIM, 3].copy()\n blobs['rois'][i][j*LIM:(j+1)*LIM, 1] = width - oldx2 - 1\n blobs['rois'][i][j*LIM:(j+1)*LIM, 3] = width - oldx1 - 1\n assert (blobs['rois'][i][j*LIM:(j+1)*LIM, 3] >= blobs['rois'][i][j*LIM:(j+1)*LIM, 1]).all()\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\n im_rois = torch.FloatTensor(t_rois).cuda()\n ic_prob, ic_prob1, ic_prob2 = net(im_data_flip, im_rois)\n scores_tmp += ic_prob + ic_prob1 + ic_prob2\n del im_rois\n\n if j is 0 :\n scores_tmp_real = scores_tmp\n pred_boxes = pred_boxes_small\n else :\n scores_tmp_real = torch.cat((scores_tmp_real, scores_tmp), dim=1)\n pred_boxes = np.vstack((pred_boxes, pred_boxes_small))\n\n\n if cfg.DEDUP_BOXES > 0:\n # Map scores and predictions back to the original set of boxes\n scores_tmp = scores_tmp_real[:,inv_index, :]\n pred_boxes = pred_boxes[inv_index, :]\n \n if i == 0: \n scores = np.copy(scores_tmp.data).squeeze()\n if len(scores.shape) == 1 :\n scores = scores[np.newaxis, :]\n else:\n scores += scores_tmp[0].data\n\n scores /= len(blobs['data']) * (1. + cfg.TEST.USE_FLIPPED)\n return scores[:,1:], pred_boxes[:, 4:]","def count_classes(labels):\n class_dict = {}\n for image in labels:\n for row in image:\n for label in row:\n if label not in class_dict:\n class_dict[label] = 1\n else:\n class_dict[label] += 1\n return class_dict","def detect_fn(image):\r\n\r\n image, shapes = model.preprocess(image)\r\n prediction_dict = model.predict(image, shapes)\r\n detections = model.postprocess(prediction_dict, shapes)\r\n\r\n return detections, prediction_dict, tf.reshape(shapes, [-1])","def describe(image):\n needle = cv2.imread(image, 0)\n orb = cv2.ORB()\n keypoints, description = orb.detectAndCompute(needle, None)\n print(keypoints)\n print(description)\n return keypoints, description","def detect(self, image):\n\n\t\t(rect, weights) = self.hog.detectMultiScale(image, winStride=(4, 4), padding=(16, 16), scale=1.09)\n\n\t\t# non-maxima suppression applied to the boxes\n\t\trect = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rect])\n\t\tboxes = non_max_suppression(rect, probs=None, overlapThresh=0.3)\n\n\t\t# draw of the rectangles around people\n\t\thuman_boxes = []\n\t\tthickness = 1\n\t\tfor i in range(len(boxes)):\n\t\t\tx = boxes[i][0]\n\t\t\ty = boxes[i][1]\n\t\t\tw = boxes[i][2]\n\t\t\th = boxes[i][3]\n\t\t\tp_w, p_h = int(0.1*w), int(0.025*h)\n\t\t\t#cv2.rectangle(image, (x + p_w, y + p_h), (x + w - p_w, y + h - p_h), (0, 255, 0), thickness)\n\n\t\t\thuman_boxes.append([(x + p_w, y + p_h), (x + w - p_w, y + h - p_h)])\n\n\t\t# reformat and rearrange the boxes for convenience\n\t\treturn human_boxes","def _load_pascal_annotation(self, index):\n image = index\n im_path = self.image_path_from_index(image)\n im = cv2.imread(im_path)\n width = im.shape[1]\n height = im.shape[0]\n num_objs = 0\n for ix, obj in enumerate(image.objects):\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\n continue \n assert(image.objects[ix].width > 0)\n assert(image.objects[ix].height > 0)\n\n num_objs += 1\n\n boxes = np.zeros((num_objs, 4), dtype=np.float32)\n\n partial_entity_class = np.zeros((num_objs, 96), dtype=np.int32)\n partial_relation_class = np.zeros((num_objs, num_objs, 43), dtype=np.int32)\n gt_classes = np.zeros((0, num_objs, 1), dtype=np.int32)\n overlaps = np.zeros((0, num_objs, self.num_classes), dtype=np.int64)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n queries = np.zeros((0, 235), dtype=np.float32)\n # Load object bounding boxes into a data frame.\n index = 0\n \n for ix, obj in enumerate(image.objects):\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\n continue\n # Make pixel indexes 0-based\n x1_offset = 0.0#image.objects[ix].width * (-0.1)\n x2_offset = 0.0#image.objects[ix].width * 0.1\n y1_offset = 0.0#image.objects[ix].height * (-0.1)\n y2_offset = 0.0#image.objects[ix].height * 0.1\n boxes[index][0] = max((image.objects[ix].x + x1_offset), 0.0)\n boxes[index][1] = max((image.objects[ix].y + y1_offset), 0.0)\n boxes[index][2] = min((image.objects[ix].x + x2_offset + image.objects[ix].width), width - 1)\n boxes[index][3] = min((image.objects[ix].y + y2_offset + image.objects[ix].height), height - 1)\n seg_areas[index] = (boxes[index][2] - boxes[index][0] + 1.0) * (boxes[index][3] - boxes[index][1] + 1.0)\n index += 1\n assert (boxes[:, 2] > boxes[:, 0]).all()\n assert (boxes[:, 3]\t > boxes[:, 1]).all() \n #load gt classes\n \n i_index = 0\n for i in range(image.objects_labels.shape[0]):\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\n continue\n partial_entity_class[i_index] = image.objects_labels[i]\n \n j_index = 0\n for j in range(image.objects_labels.shape[0]):\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\n continue\n partial_relation_class[i_index, j_index] = image.predicates_labels[i, j]\n j_index += 1\n i_index += 1\n seen = []\n for query_index in range(image.queries_gt.shape[0]):\n query_gt_classes = np.zeros((1, num_objs, 1), dtype=np.int32)\n query_overlaps = np.zeros((1, num_objs, self.num_classes), dtype=np.int64)\n query_overlaps[0, :, 3] = 1\n query_gt_classes[0, :, 0] = 3\n if image.one_hot_relations_gt[query_index][-1] == 1:\n # print \"negative triplet\"\n continue\n\n sub = image.one_hot_relations_gt[query_index][:96]\n obj = image.one_hot_relations_gt[query_index][96:96 * 2]\n rel = image.one_hot_relations_gt[query_index][96 * 2:]\n key = str(np.argmax(sub)) + \"_\" + str(np.argmax(rel)) + \"_\" + str(np.argmax(obj))\n if key in seen:\n continue\n seen.append(key)\n\n found = False\n i_index = 0\n for i in range(image.objects_labels.shape[0]):\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\n continue\n if not np.array_equal(image.objects_labels[i], sub):\n i_index += 1\n continue\n j_index = 0\n for j in range(image.objects_labels.shape[0]):\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\n continue \n\n if not np.array_equal(image.objects_labels[j], obj):\n j_index += 1\n continue\n if np.array_equal(rel, image.predicates_labels[i, j]):\n query_gt_classes[0, i_index, 0] = 1\n query_overlaps[0, i_index, 1] = 1\n query_overlaps[0, i_index, 3] = 0\n query_gt_classes[0, j_index, 0] = 2\n query_overlaps[0, j_index, 2] = 1\n query_overlaps[0, j_index, 3] = 0\n \n #partial_entity_class[i_index] = sub\n #partial_entity_class[j_index] = obj\n #partial_relation_class[i_index, j_index] = rel\n \n found = True\n j_index += 1\n i_index += 1\n if not found:\n continue\n gt_classes = np.concatenate((gt_classes, query_gt_classes), axis=0)\n overlaps = np.concatenate((overlaps, query_overlaps), axis=0)\n queries = np.concatenate((queries, image.one_hot_relations_gt[query_index].reshape([1,-1])), axis=0)\n\n return {'boxes': boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps': overlaps,\n 'flipped': False,\n 'seg_areas': seg_areas,\n 'query' : queries,\n 'partial_entity_class' : partial_entity_class,\n 'partial_relation_class' : partial_relation_class,\n 'orig_image': None}","def classify(priors, likelihoods, testData, classes):\r\n results = []\r\n for document in testData:\r\n bestClass = None\r\n bestProb = None\r\n currentProb = 0.0\r\n for cls in classes:\r\n prior = priors[cls]\r\n currentProb = log(prior)\r\n lhoods = likelihoods[cls]\r\n for (word, count) in document:\r\n if word in lhoods:\r\n currentProb += log(lhoods[word])\r\n else:\r\n currentProb += log(lhoods[None])\r\n if currentProb > bestProb or bestClass == None:\r\n bestProb = currentProb\r\n bestClass = cls\r\n results.append(bestClass)\r\n return results","def get_object_mask(self, image_id):\n image_info = self.image_meta[image_id]\n active_class_info = image_info['active_class_info']\n object_cnt = len(active_class_info)\n mask = np.zeros([image_info['height'], image_info['width'], object_cnt], dtype=np.uint8)\n for i, (object_, _, dims) in enumerate(active_class_info):\n mask[:, :, i:i + 1] = self.draw_object_shape(mask[:, :, i:i + 1].copy(), object_, 1, dims)\n \n # Handle occlusions, when two objects intersect, we should ensure that the intersection mask is\n # given to only only object.\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n # print(occlusion)\n \n for i in range(object_cnt - 2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n # Map class names to class IDs.\n return mask.astype(np.bool)","def im_detect(sess, net, im, boxes=None):\n\n blobs, im_scales = _get_blobs(im, boxes)\n\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\n # (some distinct image ROIs get mapped to the same feature ROI).\n # Here, we identify duplicate feature ROIs, so we only compute features\n # on the unique subset.\n\n if cfg.TEST.HAS_RPN:\n im_blob = blobs['data']\n blobs['im_info'] = np.array(\n [[im_blob.shape[1], im_blob.shape[2], im_scales[0]]],\n dtype=np.float32)\n # forward pass\n if cfg.TEST.HAS_RPN:\n feed_dict={net.data: blobs['data'], net.im_info: blobs['im_info'], net.keep_prob: 1.0}\n else:\n feed_dict={net.data: blobs['data'], net.rois: blobs['rois'], net.keep_prob: 1.0}\n\n run_options = None\n run_metadata = None\n if cfg.TEST.DEBUG_TIMELINE:\n run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\n run_metadata = tf.RunMetadata()\n\n cls_score, cls_prob, bbox_pred, rois = sess.run([net.get_output('cls_score'), net.get_output('cls_prob'), net.get_output('bbox_pred'),net.get_output('rois')],\n feed_dict=feed_dict,\n options=run_options,\n run_metadata=run_metadata)\n\n if cfg.TEST.HAS_RPN:\n assert len(im_scales) == 1, \"Only single-image batch implemented\"\n boxes = rois[:, 1:5] / im_scales[0]\n\n\n if cfg.TEST.SVM:\n # use the raw scores before softmax under the assumption they\n # were trained as linear SVMs\n scores = cls_score\n else:\n # use softmax estimated probabilities\n scores = cls_prob\n\n if cfg.TEST.BBOX_REG:\n # Apply bounding-box regression deltas\n box_deltas = bbox_pred\n pred_boxes = bbox_transform_inv(boxes, box_deltas)\n pred_boxes = _clip_boxes(pred_boxes, im.shape)\n else:\n # Simply repeat the boxes, once for each class\n pred_boxes = np.tile(boxes, (1, scores.shape[1]))\n\n if cfg.TEST.DEBUG_TIMELINE:\n trace = timeline.Timeline(step_stats=run_metadata.step_stats)\n trace_file = open(str(long(time.time() * 1000)) + '-test-timeline.ctf.json', 'w')\n trace_file.write(trace.generate_chrome_trace_format(show_memory=False))\n trace_file.close()\n\n return scores, pred_boxes","def preprocessing(image_data, max_height, max_width):\n img = image_data[\"image\"]\n img = resize_image(img, max_height, max_width)\n gt_boxes = image_data[\"objects\"][\"bbox\"]\n gt_labels = image_data[\"objects\"][\"label\"]\n return img, gt_boxes, gt_labels","def detect_primary_objects(gray, haar_file, params, num_primary_obj=1, max_iter=10, boost_flag=True, verbose=False):\n haar_cascade = cv.CascadeClassifier(haar_file)\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\n num_detected = len(detected_objects)\n num_detected_prev = num_detected\n if verbose:\n print(f\"Initial # of Objects Detected = {num_detected}\")\n num_iter = 0\n boost_factor = 1\n while num_detected != num_primary_obj and num_iter != max_iter:\n num_iter += 1\n if verbose:\n print(f\"Iteration # = {num_iter}\")\n # Update minNeighbors value in copy of params dict\n if num_iter == 1:\n params_new = params.copy()\n elif num_iter == max_iter:\n print(f\"Maximum # of iterations ({max_iter}) reached!\")\n # Change minNeighbors up/down depending on whether num detected is too high/low\n # Steps up are twice as big as steps down, and boost_factor determines step size\n if num_detected < num_primary_obj and params_new['minNeighbors'] > 4:\n params_new['minNeighbors'] -= boost_factor\n elif num_detected < num_primary_obj and params_new['minNeighbors'] > 1:\n params_new['minNeighbors'] -= 1 \n elif num_detected > num_primary_obj:\n params_new['minNeighbors'] += 2 * boost_factor\n else:\n print(f\"Unable to detect {num_primary_obj} primary object(s) in input image\")\n print(f\"Verify that either 1) num_detected is zero ({num_detected==0}) and minNeighbors is one ({params_new['minNeighbors']==1})\")\n print(f\"OR 2) the maximum # of iterations has been reached ({num_iter==max_iter})\")\n print(\"If either of these scenarios occurs, consider changing the input scaleFactor and/or initial minNeighbors value. If neither 1) or 2) applies, then there is an unknown bug somewhere that should be investigated!!!\")\n if verbose:\n print(f\"minNeighbors = {params_new['minNeighbors']}\")\n detected_objects = haar_cascade.detectMultiScale(gray, **params_new)\n num_detected = len(detected_objects)\n if num_detected == num_detected_prev and boost_flag:\n boost_factor += 1\n else:\n boost_factor = 1\n num_detected_prev = num_detected\n if verbose:\n print(f\"Final # of Objects Detected = {num_detected}\")\n return detected_objects","def visualize_detection(self, img, dets, seg, classes=[], thresh=0.6):\n from dataset.cs_labels import labels\n lut = np.zeros((256,3))\n for l in labels:\n if l.trainId<255 and l.trainId>=0:\n lut[l.trainId,:]=list(l.color)\n palette = lut\n # det2seg = {0:6,1:7,2:11,3:12,4:13,5:14,6:15,7:16,8:17,9:18,}\n det2seg = {0:11,1:12,2:13,3:14,4:15,5:16,6:17,7:18,}\n \n import cv2\n import random\n tic = time.time()\n color_white = (255, 255, 255)\n im = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # change to bgr\n yscale, xscale, ch = im.shape\n color = (0,0,128)\n fontFace = cv2.FONT_HERSHEY_PLAIN\n fontScale = .8*(yscale/float(320))\n thickness = 2 if yscale>320 else 1\n idx = np.argsort(dets[:,6],axis=0)[::-1] ## draw nearest first !!\n dets = dets[idx,:]\n for det in dets:\n cls_id = int(det[0])\n bbox = [det[2]*xscale,det[3]*yscale,det[4]*xscale,det[5]*yscale]\n score = det[1]\n distance = det[-1]\n if score > thresh:\n bbox = map(int, bbox)\n color = palette[det2seg[int(det[0])],(2,1,0)]\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=thickness)\n text = '%s %.0fm' % (short_class_name[classes[cls_id]], distance*255., )\n textSize, baseLine = cv2.getTextSize(text, fontFace, fontScale, thickness=1)\n cv2.rectangle(im, (bbox[0], bbox[1]-textSize[1]), (bbox[0]+textSize[0], bbox[1]), color=(128,0,0), thickness=-1)\n cv2.putText(im, text, (bbox[0], bbox[1]),\n color=color_white, fontFace=fontFace, fontScale=fontScale, thickness=1)\n disp = im.copy()\n if False: #disp.shape[1]>1000:\n hh, ww, ch = disp.shape\n resized = cv2.resize(disp, (int(round(ww*.92)),int(round(hh*.92))))\n else:\n resized = disp\n cv2.imshow(\"result\", resized)\n # cv2.imwrite(\"data/cityscapes/Results/stuttgart_%06d.png\" % (self.imgidx,), resized)\n # self.imgidx += 1","def classify(img, c_model):\n #global class_graph\n\n #img = load_img(im_path,target_size=(input_height, input_width))\n #img = img_to_array(img)\n im_size = 128\n # resize \n\n img = cv2.resize(img, (im_size,im_size))\n\n img = img.astype(\"float\") / 255.0\n img = np.expand_dims(img, axis=0)\n with class_graph.as_default():\n predictions = c_model.predict(img)[0]\n\n return predictions","def get_classification(self, image):\n\n\tif 'session' in locals() and session is not None:\n \t print('Close interactive session')\n session.close()\n\n time_start = time.time()\n #TODO implement light color prediction\n #image_np = self.__preprocess_image(image)\n \timage_np = image \n \n \t# Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image_np, axis=0)\n time0 = time.time()\n\n # Actual detection.\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n\n time1 = time.time()\n\n output = self.__postprocessing_detected_box(scores[0], classes[0])\n rospy.loginfo('Time in seconds' + str(time1-time_start)+' Result:'+self.__traffic_id_to_name(output))\n return output"],"string":"[\n \"def detect_objects(interpreter, image):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n count = int(get_output_tensor(interpreter, 3))\\n\\n results = []\\n for i in range(count):\\n # Only check for people that meet the threshold\\n if classes[i] == 0.0 and scores[i] >= THRESHOLD:\\n result = {\\n \\\"bounding_box\\\": boxes[i],\\n \\\"class_id\\\": classes[i],\\n \\\"score\\\": scores[i],\\n }\\n results.append(result)\\n return results\",\n \"def detect_objects(image, threshold, classes_incl=None):\\n set_input_tensor(image)\\n interpreter.invoke()\\n\\n # Get all output details\\n boxes = get_output_tensor(0)\\n classes = get_output_tensor(1)\\n scores = get_output_tensor(2)\\n count = int(get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= threshold:\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': int(classes[i]),\\n 'score': scores[i]\\n }\\n if not classes_incl:\\n results.append(result)\\n elif classes[i] in classes_incl:\\n results.append(result)\\n return results\",\n \"def detect_objects(interpreter, image):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n #boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n #count = int(get_output_tensor(interpreter, 3))\\n\\n #results = []\\n #for i in range(count):\\n # if scores[i] >= threshold:\\n # result = {\\n # #'bounding_box': boxes[i],\\n # 'class_id': classes[i],\\n # 'score': scores[i]\\n # }\\n # results.append(result)\\n \\n \\n #print(\\\"detection results:\\\\n\\\" + str(results))\\n #return results\\n return np.array([int(_class) for _class in classes]), np.array(scores)\",\n \"def detect_objects(self, image):\\n preprocessed_image = self._preprocess_image(image)\\n\\n # Feed the input image to the model\\n self._set_input_tensor(preprocessed_image)\\n self._interpreter.invoke()\\n\\n # Get all outputs from the model\\n boxes = self._get_output_tensor(0)\\n classes = self._get_output_tensor(1)\\n scores = self._get_output_tensor(2)\\n count = int(self._get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= self.THRESHOLD:\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': classes[i],\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def detect_objects(self, image):\\n # Feed the input image to the model\\n self.set_input_tensor(image)\\n self.model.invoke()\\n\\n # Get all outputs from the model\\n boxes = self.get_output_tensor(0)\\n classes = self.get_output_tensor(1)\\n scores = self.get_output_tensor(2)\\n count = int(self.get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': int(classes[i]),\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def detect_class_onpic(boxes, allowed_classes):\\n object_class = \\\"all\\\"\\n highest_prob = 0\\n for box in boxes:\\n box_prob = float(box[1].strip('%')) / 100.0\\n if box[0] in allowed_classes and box_prob > highest_prob:\\n highest_prob = box_prob\\n object_class = box[0]\\n return object_class, highest_prob\",\n \"def detect_objects(self, image, threshold):\\n self.set_input_tensor(image)\\n self.interpreter.invoke()\\n\\n # Get all output details\\n boxes = self.get_output_tensor(0)\\n classes = self.get_output_tensor(1)\\n scores = self.get_output_tensor(2)\\n count = int(self.get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= threshold:\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': classes[i],\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def detect_image_objects(gray, detect_params, detect_type=\\\"all\\\", label=-1, verbose=False):\\n if detect_type == \\\"all\\\":\\n detected_rects = detect_all_objects(gray, verbose=verbose, **detect_params)\\n elif detect_type == \\\"primary\\\":\\n detected_rects = detect_primary_objects(gray, verbose=verbose, **detect_params)\\n else:\\n print(f\\\"Unrecongized input value for detect_type, {detect_type}, so no objects were detected!\\\")\\n print(\\\"Please provide a string value for detect_type of either 1) 'all' or 2) 'primary'\\\")\\n detected_rects = None\\n if isinstance(detected_rects, np.ndarray):\\n features_labels = get_detected_features_labels(gray, detected_rects, label=label, verbose=verbose)\\n return features_labels\",\n \"def demo(net, image_name,num_class,save_ff):\\r\\n\\r\\n # Load the demo image\\r\\n #im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\\r\\n im_file=image_name\\r\\n im = cv2.imread(im_file)\\r\\n\\r\\n # Detect all object classes and regress object bounds\\r\\n timer = Timer()\\r\\n timer.tic()\\r\\n #for zzz in range(100):\\r\\n scores, boxes = im_detect(net, im)\\r\\n timer.toc()\\r\\n print ('Detection took {:.3f}s for '\\r\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\r\\n\\r\\n # Visualize detections for each class\\r\\n CONF_THRESH = 0.35\\r\\n NMS_THRESH = 0.3\\r\\n thresh=CONF_THRESH\\r\\n for cls_ind, cls in enumerate(range(num_class)):#CLASSES[1:]\\r\\n cls_ind += 1 # because we skipped background\\r\\n # cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\r\\n # cls_scores = scores[:, cls_ind]\\r\\n # dets = np.hstack((cls_boxes,\\r\\n # cls_scores[:, np.newaxis])).astype(np.float32)\\r\\n inds = np.where(scores[:, cls_ind] > thresh)[0]\\r\\n cls_scores = scores[inds, cls_ind]\\r\\n if cfg.TEST.AGNOSTIC:\\r\\n cls_boxes = boxes[inds, 4:8]\\r\\n else:\\r\\n cls_boxes = boxes[inds, cls_ind*4:(cls_ind+1)*4]\\r\\n dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \\\\\\r\\n .astype(np.float32, copy=False)\\r\\n keep = nms(dets, NMS_THRESH)\\r\\n dets = dets[keep, :]\\r\\n #vis_detections(im, cls, dets, thresh=CONF_THRESH)\\r\\n inds = np.where(dets[:, -1] >= thresh)[0]\\r\\n if len(inds) == 0:\\r\\n continue\\r\\n\\r\\n im_tmp = im#im[:, :, (2, 1, 0)]\\r\\n for i in inds:\\r\\n bbox = dets[i, :4]\\r\\n score = dets[i, -1]\\r\\n print bbox,score,cls\\r\\n cv2.rectangle(im_tmp, (bbox[0],bbox[1]), (bbox[2],bbox[3]), (0,0,255),2)\\r\\n #save_ff=\\\"/storage2/liushuai/faster_rcnn/FasterRCNN-Encapsulation-Cplusplus/faster_cxx_lib_ev2641/test_result.jpg\\\"\\r\\n im_tmp = im#im[:, :, (2, 1, 0)]\\r\\n cv2.imwrite(save_ff,im_tmp)\\r\\n #save_pic(im, cls, dets, thresh=CONF_THRESH,save_ff)\\r\",\n \"def determine_object_class(self, components_detected):\\n for subimage, components in components_detected.items():\\n\\n for component in components:\\n\\n if component.class_id == 0:\\n component.object_name = \\\"insl\\\" # Insulator\\n\\n elif component.class_id == 1:\\n component.object_name = \\\"dump\\\" # Vibration dumper\\n\\n else:\\n component.object_name = \\\"pillar\\\"\",\n \"def __detect_objs(self):\\n while True:\\n # Wait for input images\\n if (not self.__predict_start) or \\\\\\n (self.__img is None):\\n continue\\n\\n # Client for detection\\n client = vision.ImageAnnotatorClient()\\n\\n # Encode image to binary\\n _, img_buffer = cv2.imencode(\\\".jpg\\\", self.__img)\\n img_bytes = img_buffer.tobytes()\\n\\n # Change to vision Image type\\n image = vision.Image(content=img_bytes)\\n # Detect Person\\n self.__detect_info = client.object_localization(image=image,\\n max_results=self.__max_results\\n ).localized_object_annotations\\n cv2.waitKey(30)\",\n \"def detect_objects(self, image, threshold=0.5, needs_preprocessing=False, temp_path='temp.jpg',\\n version='default'):\\n if self.transform_service:\\n image = self.transform_service.predict_single(image, version)\\n return self.model_service.detect_objects(image, threshold, needs_preprocessing, temp_path)\",\n \"def face_detect(sess, net, image_name):\\n\\n\\t# Load the demo image\\n\\tim_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\\n\\tim = cv2.imread(im_file)\\n\\n\\t# Detect all object classes and regress object bounds\\n\\ttimer = Timer()\\n\\ttimer.tic()\\n\\t# scores, boxes = im_detect(sess, net, im)\\n\\tscores, boxes, eyes, smiles = im_detect_ori(sess, net, im)\\n\\ttimer.toc()\\n\\tprint ('Detection took {:.3f}s for '\\n\\t\\t\\t'{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n\\t# Visualize detections for each class\\n\\t# im = im[:, :, (2, 1, 0)]\\n\\t# fig, ax = plt.subplots(figsize=(8, 8))\\n\\t# ax.imshow(im, aspect='equal')\\n\\n\\tCONF_THRESH = 0.9\\n\\tNMS_THRESH = 0.3\\n\\tfor cls_ind, cls in enumerate(CLASSES[20:]):\\n\\t\\tcls_ind += 20 # because we skipped everything except face\\n\\t\\tcls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n\\t\\tcls_scores = scores[:, cls_ind]\\n\\t\\tdets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)\\n\\t\\tkeep = nms(dets, NMS_THRESH)\\n\\t\\tdets = dets[keep, :]\\n\\t\\teye = eyes[keep, :]\\n\\t\\tsmile= smiles[keep, :]\\n\\n\\tinds = np.where(dets[:, -1] >= CONF_THRESH)[0]\\n\\tface_num = len(inds)\\n\\tprint '{} faces detected!'.format(face_num)\\n\\tdets = dets[inds, :]\\n\\teye = eye[inds, 1]\\n\\tsmile = smile[inds, 1]\\n\\n\\treturn dets, eye, smile\",\n \"def annotate_image(self, image, results):\\n predictedObjects = []\\n for i in range(len(results)):\\n objectParameters = []\\n x = int(results[i][1])\\n y = int(results[i][2])\\n w = int(results[i][3])\\n h = int(results[i][4])\\n # print(x, y, w, h, results[i][0])\\n imageHeight, imageWidth, _ = image.shape\\n w = w // 2\\n h = h // 2\\n # change to truncate boxes which go outside the image\\n xmin, xmax, ymin, ymax = 0, 0, 0, 0\\n xmin = 3 if not max(x - w, 0) else (x - w)\\n xmax = imageWidth - 3 if not min(x + w - imageWidth, 0) \\\\\\n else (x + w)\\n ymin = 1 if not max(y - h, 0) else (y - h)\\n ymax = imageHeight - 3 if not min(y + h - imageHeight, 0) \\\\\\n else (y + h)\\n if self.verbose:\\n print('Class : ' + results[i][0] + ', [x, y, w, h] [' +\\n str(x) + ', ' + str(y) + ', ' + str(w) + ', ' + str(h) +\\n '] Confidence : ' + str(results[i][5]))\\n \\n # Each class must have a unique color\\n color = tuple([(j * (1+self.classes.index(results[i][0])) % 255) \\\\\\n for j in self.seed])\\n cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)\\n if ymin <= 20:\\n cv2.rectangle(\\n image, (xmin, ymin), (xmax, ymin + 20), color, -1\\n )\\n cv2.putText(\\n image, results[i][0] + ': %.2f' % results[i][5],\\n (xmin+5, ymin+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 2\\n )\\n else:\\n cv2.rectangle(image, (xmin, ymin), (xmax, ymin-20), color, -1)\\n cv2.putText(\\n image, results[i][0] + ': %.2f' % results[i][5],\\n (xmin+5, ymin-8), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 2\\n )\\n objectParameters = [\\n results[i][0], xmin, ymin, xmax, ymax, results[i][5]\\n ]\\n predictedObjects.append(objectParameters)\\n return image, predictedObjects\\n # if self.outputFile:\\n # cv2.imwrite(self.outputFile,image)\",\n \"def demo(net, data_dir, imgfile, out_dir):\\n\\n # Load the demo image\\n im_file = os.path.join(data_dir, imgfile)\\n im = cv2.imread(im_file)\\n\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im)\\n scores = np.squeeze(scores)\\n timer.toc()\\n print ('Detection took {:.3f}s for '\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0.12\\n NMS_THRESH = 0.3\\n color_white = (0, 0, 0)\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 \\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n color = (random.randint(0, 256), random.randint(0, 256), random.randint(0, 256))\\n inds = np.where(dets[:, -1] >= CONF_THRESH)[0]\\n for i in inds:\\n bbox = dets[i, :4]\\n score = dets[i, -1]\\n bbox = map(int, bbox)\\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=4)\\n cv2.putText(im, '%s %.3f' % (cls, score), (bbox[0], bbox[1] + 15),\\n color=color_white, fontFace=cv2.FONT_HERSHEY_COMPLEX, fontScale=0.5)\\n return im\",\n \"def apply_classifier(self):\\n for detected_object in self.detected_objects:\\n detected_object.predict_class(self.original_image)\",\n \"def classify_image(image):\\n image_path = image.filename\\n image_data = np.array(Image.open(image.stream))\\n image_data = skimage.img_as_float(image_data).astype(np.float2)\\n with classifier_lock:\\n classification = classifier.predict([image_data])[0]\\n return {\\\"suggested_tags\\\": predicted_tags(classification),\\n \\\"classification_vector\\\": classification,\\n \\\"image_url\\\": image_path}\",\n \"def on_image(image):\\n objects = [obj for obj in coco.classify(image) if obj.confidence > config.OBJECT_CONFIDENCE_THRESHOLD]\\n queue.put((image, objects))\",\n \"def detect_objects(snap):\\n client = vision.ImageAnnotatorClient()\\n print(snap)\\n\\n with open(snap, 'rb') as im_file:\\n content = im_file.read()\\n image = vision.Image(content=content)\\n\\n objects = client.object_localization(image=image).localized_object_annotations\\n\\n print(f\\\"Found {len(objects)} objects\\\")\\n [print(f\\\"{objet.name} : {round(objet.score*100,2)}\\\") for objet in objects]\\n \\n return objects\",\n \"def classify_images():\\n\\n # Load the desired image\\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\\n img = image.load_img(img_path, target_size=(299, 299))\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n x = preprocess_input(x)\\n\\n model = InceptionV3(weights=\\\"imagenet\\\")\\n preds = model.predict(x)\\n # decode the results into a list of tuples (class, description, probability)\\n # (one such list for each sample in the batch)\\n print('Predicted:', decode_predictions(preds, top=3)[0])\",\n \"def get_object_detections(self):\\n detections = self.__get_cropped_detections(self.image)\\n return detections\",\n \"def demo(net, image_name, classes):\\n\\n # Load pre-computed Selected Search object proposals\\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\\n obj_proposals = sio.loadmat(box_file)['boxes']\\n\\n # Load the demo image\\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\\n im_file = os.path.join(test_images_path, image_name + '.jpg')\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im, obj_proposals)\\n timer.toc()\\n # print ('Detection took {:.3f}s for '\\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0\\n NMS_THRESH = 0.3\\n max_inds = 0\\n max_score = 0.0\\n for cls in classes:\\n cls_ind = CLASSES.index(cls)\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n keep = np.where(cls_scores >= CONF_THRESH)[0]\\n cls_boxes = cls_boxes[keep, :]\\n cls_scores = cls_scores[keep]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\\n # CONF_THRESH, image_name)\\n #if get_max!=[]: \\n\\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\\n #print image_name,cls,tmp\\n\\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\\n #print dets[:,-1]\\n #print image_name,max_score\\n file.writelines([image_name,'\\\\t',cls,'\\\\t',str(tmp),'\\\\n'])\\n if(max_score<tmp):\\n max_score=tmp\\n cls_max=cls\\n print image_name,cls_max,max_score\",\n \"def classify(self):\\n infer = self.model.signatures['serving_default']\\n for i, original_image in enumerate(self.images):\\n image = original_image.copy()\\n image = cv.cvtColor(image, cv.COLOR_BGR2RGB)\\n image = cv.resize(image, (self.image_size, self.image_size))\\n image = image / 255.\\n\\n image = [image]\\n image = np.asarray(image).astype(np.float32)\\n batch_data = tf.constant(image)\\n pred_bbox = infer(batch_data)\\n for key, value in pred_bbox.items():\\n boxes = value[:, :, 0:4]\\n pred_conf = value[:, :, 4:]\\n\\n boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(\\n boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),\\n scores=tf.reshape(\\n pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),\\n max_output_size_per_class=10,\\n max_total_size=10,\\n iou_threshold=FLAGS.iou,\\n score_threshold=FLAGS.score\\n )\\n\\n height, width, _ = original_image.shape\\n\\n print(scores)\\n classes = classes[0]\\n print(classes)\\n\\n bbox = boxes[0][0].numpy()\\n bbox[0] = int(bbox[0] * height)\\n bbox[2] = int(bbox[2] * height)\\n bbox[1] = int(bbox[1] * width)\\n bbox[3] = int(bbox[3] * width)\\n\\n if BIRD_CLASS in classes:\\n idx = np.where(classes == BIRD_CLASS)\\n bbox = bbox.astype(np.int)\\n x = int((bbox[1] + bbox[3]) / 2)\\n y = int((bbox[0] + bbox[2]) / 2)\\n self.thumbnail_center.append((x, y))\\n cropped_img = original_image[bbox[0]:bbox[2], bbox[1]: bbox[3]]\\n self.bird_images.append(cropped_img)\\n self.confidence_arr.append(scores[idx[0][0]][0])\\n\\n self.generate_thumbnail(size=150)\",\n \"def classify_image_proba(image, model, image_box=None):\\n images_list = []\\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\\n # box argument clips image to (x1, y1, x2, y2)\\n image = np.array(image)\\n images_list.append(image)\\n \\n return [np.amax(model.predict(np.array(images_list)))]\",\n \"def detectObjects(image):\\n\\tgrayscale = cvCreateImage(cvSize(image.width, image.height), 8, 1)\\n\\tcvCvtColor(image, grayscale, CV_BGR2GRAY)\\n\\n\\tstorage = cvCreateMemStorage(0)\\n\\tcvClearMemStorage(storage)\\n\\tcvEqualizeHist(grayscale, grayscale)\\n\\tcascade = cvLoadHaarClassifierCascade(\\n\\t\\t'/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml',\\n\\t\\tcvSize(1,1))\\n\\n\\tscalefactor = 1.1 # How much to increase window size each pass\\n\\tminsize = 50 # Smallest face to detect. Up this if you have small falsepositives\\n\\tfaces = cvHaarDetectObjects(grayscale, cascade, storage, scalefactor, 50,\\n\\t\\t\\t\\tCV_HAAR_DO_CANNY_PRUNING, cvSize(minsize, minsize))\\n\\n\\treturn [(f.x, f.y, f.x + f.width, f.y + f.height) for f in faces]\",\n \"def get_classification(self, image):\\n #TODO implement light color prediction\\n max_idx = 4\\n with self.detection_graph.as_default():\\n with tf.Session(graph=self.detection_graph) as sess:\\n # Definite input and output Tensors for detection_graph\\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\\n \\n # Each box represents a part of the image where a particular object was detected.\\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\\n \\n # Each score represent how level of confidence for each of the objects.\\n # Score is shown on the result image, together with the class label.\\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\\n image_np_expanded = np.expand_dims(image, axis=0)\\n # Actual detection.\\n (boxes, scores, classes, num) = sess.run(\\n [detection_boxes, detection_scores, detection_classes, num_detections],\\n feed_dict={image_tensor: image_np_expanded})\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n min_score_thresh = .50\\n # find majority light state\\n counter = [0, 0, 0, 0, 0]\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > min_score_thresh:\\n counter[classes[i]] += 1\\n for i in range(1, 5):\\n if counter[i] > counter[max_idx]:\\n max_idx = i\\n return self.classmap[max_idx]\",\n \"def compute_classifications(depc, gid_list, config=None):\\n logger.info('[ibs] Process Image Classifications')\\n logger.info('config = {!r}'.format(config))\\n # Get controller\\n ibs = depc.controller\\n depc = ibs.depc_image\\n if config['classifier_algo'] in ['cnn']:\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (192, 192),\\n }\\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\\n result_list = ibs.generate_thumbnail_class_list(thumbnail_list, **config)\\n elif config['classifier_algo'] in ['svm']:\\n from wbia.algo.detect.svm import classify\\n\\n config_ = {'algo': 'resnet'}\\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\\n elif config['classifier_algo'] in ['densenet']:\\n from wbia.algo.detect import densenet\\n\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\\n }\\n thumbpath_list = ibs.depc_image.get(\\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\\n )\\n result_list = densenet.test(thumbpath_list, ibs=ibs, gid_list=gid_list, **config)\\n elif config['classifier_algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n classifier_weight_filepath = classifier_weight_filepath.strip().split(';')\\n\\n assert len(classifier_weight_filepath) == 2\\n classifier_algo_, model_tag_ = classifier_weight_filepath\\n\\n include_grid2 = config['classifier_algo'] in ['tile_aggregation']\\n tid_list = ibs.scout_get_valid_tile_rowids(\\n gid_list=gid_list, include_grid2=include_grid2\\n )\\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\\n confidence_list = ibs.scout_wic_test(\\n tid_list, classifier_algo=classifier_algo_, model_tag=model_tag_\\n )\\n\\n gid_dict = {}\\n for ancestor_gid, tid, confidence in zip(\\n ancestor_gid_list, tid_list, confidence_list\\n ):\\n if ancestor_gid not in gid_dict:\\n gid_dict[ancestor_gid] = []\\n gid_dict[ancestor_gid].append(confidence)\\n\\n result_list = []\\n for gid in tqdm.tqdm(gid_list):\\n gid_confidence_list = gid_dict.get(gid, None)\\n assert gid_confidence_list is not None\\n best_score = np.max(gid_confidence_list)\\n\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in ['densenet+neighbors']:\\n raise NotImplementedError\\n # ut.embed()\\n # classifier_weight_filepath = config['classifier_weight_filepath']\\n\\n # all_bbox_list = ibs.get_image_bboxes(gid_list)\\n # wic_confidence_list = ibs.scout_wic_test(gid_list, classifier_algo='densenet',\\n # model_tag=classifier_weight_filepath)\\n #\\n # ancestor_gid_list = list(set(ibs.get_tile_ancestor_gids(gid_list)))\\n # all_tile_list = list(set(ibs.scout_get_valid_tile_rowids(gid_list=ancestor_gid_list)))\\n # all_bbox_list = ibs.get_image_bboxes(all_tile_list)\\n # all_confidence_list = ibs.scout_wic_test(all_tile_list, classifier_algo='densenet',\\n # model_tag=classifier_weight_filepath)\\n #\\n # TODO: USE THRESHOLDED AVERAGE, NOT MAX\\n # result_list = []\\n # for gid, wic_confidence in zip(gid_list, wic_confidence_list):\\n # best_score = wic_confidence\\n # for aid in aid_list:\\n # wic_confidence_ = aid_conf_dict.get(aid, None)\\n # assert wic_confidence_ is not None\\n # best_score = max(best_score, wic_confidence_)\\n #\\n # if wic_confidence < 0.5:\\n # best_key = 'negative'\\n # best_score = 1.0 - best_score\\n # else:\\n # best_key = 'positive'\\n # if best_score > wic_confidence:\\n # recovered += 1\\n # result = (best_score, best_key, )\\n # result_list.append(result)\\n elif config['classifier_algo'] in ['scout_detectnet']:\\n import json\\n\\n json_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\\n assert exists(json_filepath)\\n with open(json_filepath, 'r') as json_file:\\n values = json.load(json_file)\\n annotations = values.get('annotations', {})\\n\\n gpath_list = ibs.get_image_paths(gid_list)\\n gname_list = [split(gpath)[1] for gpath in gpath_list]\\n\\n result_list = []\\n for gname in gname_list:\\n annotation = annotations.get(gname, None)\\n assert annotation is not None\\n\\n best_score = 1.0\\n if len(annotation) == 0:\\n best_key = 'negative'\\n else:\\n best_key = 'positive'\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in ['scout_detectnet_csv', 'scout_faster_rcnn_csv']:\\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\\n\\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\\n csv_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\\n\\n assert exists(manifest_filepath)\\n assert exists(csv_filepath)\\n\\n manifest_dict = {}\\n with open(manifest_filepath, 'r') as manifest_file:\\n manifest_file.readline() # Discard column header row\\n manifest_line_list = manifest_file.readlines()\\n for manifest_line in manifest_line_list:\\n manifest = manifest_line.strip().split(',')\\n assert len(manifest) == 2\\n manifest_filename, manifest_uuid = manifest\\n manifest_dict[manifest_filename] = manifest_uuid\\n\\n csv_dict = {}\\n with open(csv_filepath, 'r') as csv_file:\\n csv_file.readline() # Discard column header row\\n csv_line_list = csv_file.readlines()\\n for csv_line in csv_line_list:\\n csv = csv_line.strip().split(',')\\n assert len(csv) == 2\\n csv_filename, csv_score = csv\\n csv_uuid = manifest_dict.get(csv_filename, None)\\n assert (\\n csv_uuid is not None\\n ), 'Test image {!r} is not in the manifest'.format(\\n csv,\\n )\\n csv_dict[csv_uuid] = csv_score\\n\\n result_list = []\\n for uuid_str in uuid_str_list:\\n best_score = csv_dict.get(uuid_str, None)\\n assert best_score is not None\\n\\n if config['classifier_algo'] in ['scout_detectnet_csv']:\\n assert best_score in ['yes', 'no']\\n best_key = 'positive' if best_score == 'yes' else 'negative'\\n best_score = 1.0\\n elif config['classifier_algo'] in ['scout_faster_rcnn_csv']:\\n best_score = float(best_score)\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n else:\\n raise ValueError\\n\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in [\\n 'lightnet',\\n 'densenet+lightnet',\\n 'densenet+lightnet!',\\n ]:\\n min_area = 10\\n\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n classifier_weight_filepath = classifier_weight_filepath.strip().split(',')\\n\\n if config['classifier_algo'] in ['lightnet']:\\n assert len(classifier_weight_filepath) == 2\\n weight_filepath, nms_thresh = classifier_weight_filepath\\n wic_thresh = 0.0\\n nms_thresh = float(nms_thresh)\\n wic_confidence_list = [np.inf] * len(gid_list)\\n wic_filter = False\\n elif config['classifier_algo'] in ['densenet+lightnet', 'densenet+lightnet!']:\\n assert len(classifier_weight_filepath) == 4\\n (\\n wic_model_tag,\\n wic_thresh,\\n weight_filepath,\\n nms_thresh,\\n ) = classifier_weight_filepath\\n wic_thresh = float(wic_thresh)\\n nms_thresh = float(nms_thresh)\\n wic_confidence_list = ibs.scout_wic_test(\\n gid_list, classifier_algo='densenet', model_tag=wic_model_tag\\n )\\n wic_filter = config['classifier_algo'] in ['densenet+lightnet']\\n else:\\n raise ValueError\\n\\n flag_list = [\\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\\n ]\\n if wic_filter:\\n gid_list_ = ut.compress(gid_list, flag_list)\\n else:\\n gid_list_ = gid_list[:]\\n config = {\\n 'grid': False,\\n 'algo': 'lightnet',\\n 'config_filepath': weight_filepath,\\n 'weight_filepath': weight_filepath,\\n 'nms': True,\\n 'nms_thresh': nms_thresh,\\n 'sensitivity': 0.0,\\n }\\n prediction_list = depc.get_property(\\n 'localizations', gid_list_, None, config=config\\n )\\n prediction_dict = dict(zip(gid_list_, prediction_list))\\n\\n result_list = []\\n for gid, wic_confidence, flag in zip(gid_list, wic_confidence_list, flag_list):\\n if not flag:\\n best_key = 'negative'\\n best_score = 1.0 - wic_confidence\\n else:\\n prediction = prediction_dict.get(gid, None)\\n assert prediction is not None\\n\\n best_score = 0.0\\n if prediction is not None:\\n score, bboxes, thetas, confs, classes = prediction\\n for bbox, conf in zip(bboxes, confs):\\n xtl, ytl, w, h = bbox\\n area = w * h\\n if area >= min_area:\\n best_score = max(best_score, conf)\\n\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n else:\\n raise ValueError(\\n 'specified classifier algo is not supported in config = {!r}'.format(config)\\n )\\n\\n # yield detections\\n for result in result_list:\\n yield result\",\n \"def demo(sess, net, color_image, depth_colormap):\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, color_image)\\n timer.toc()\\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0.7\\n NMS_THRESH = 0.3\\n dets_col = []\\n cls_col = []\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n dets_col.append(dets)\\n cls_col.append(cls)\\n\\n vis_detections(color_image, depth_colormap, cls_col, dets_col, thresh=CONF_THRESH)\\n\\n depth_col, bbox_col = calc_histogram(depth_image, cls_col, dets_col, thresh=CONF_THRESH)\\n print(\\\"box depth:\\\", depth_col[0], \\\"sucker depth:\\\", depth_col[1])\\n print(\\\"box bbox:\\\", bbox_col[0], \\\"sucker bbox\\\", bbox_col[1])\",\n \"def vis_detections(im, class_name, dets, thresh=0.8):\\n\\n dict = {'HolderA': 'Holder', 'WheelA': 'WheelA', 'WheelB': 'WheelB', 'BrakeA': 'Brake', 'SpringA': 'Spring',\\n 'BuckleA': 'BuckleA', 'BuckleB': 'BuckleB', 'TubeA': 'Tube', 'NutA': 'NutA', 'ScrewA': 'ScrewA',\\n 'NutB': 'NutB', 'ScrewB': 'ScrewB',\\n 'WireA': 'Wire', 'PlateA': 'PlateA', 'PlateB': 'PlateB', 'PlateD': 'PlateC', 'PlateE': 'PlateD',\\n 'BoltA': 'Bolt', 'LoopB': 'Loop', 'JointA': 'JointA', 'JointB': 'JointB', 'FixatorA': 'Fixator',\\n 'BearingA': 'Bearing', 'PlugA': 'Plug'}\\n\\n for i in range(np.minimum(10, dets.shape[0])):\\n bbox = tuple(int(np.round(x)) for x in dets[i, :4])\\n score = dets[i, -1]\\n if score > thresh:\\n # Color site: http://www.wahart.com.hk/rgb.htm\\n if class_name == 'HolderA':\\n color = (255, 255, 0) # Cyan\\n elif class_name == 'WheelA':\\n color = (212, 255, 127) # Aquamarina\\n elif class_name == 'WheelB':\\n color = (99, 99, 238) # IndianRed2\\n elif class_name == 'BrakeA':\\n color = (99, 99, 238) # IndianRed2\\n elif class_name == 'SpringA':\\n color = (180, 130, 70) # SteelBlue\\n elif class_name == 'BuckleA':\\n color = (205, 0, 0) # MediumBlue\\n elif class_name == 'BuckleB':\\n color = (170, 205, 102) # MediumAquamarine\\n elif class_name == 'BuckleC':\\n color = (0, 252, 124) # LawnGreen\\n elif class_name == 'BuckleD':\\n color = (50, 205, 50) # LimeGreen\\n elif class_name == 'TubeA':\\n color = (147, 112, 219) # PaleVioletRed\\n elif class_name == 'ScrewA':\\n color = (240, 32, 160) # Purple\\n elif class_name == 'ScrewB':\\n color = (0, 165, 255) # Orange1\\n elif class_name == 'ScrewC':\\n color = (48, 48, 255) # Firebrick1\\n elif class_name == 'NutA':\\n color = (0, 255, 255) # Yellow\\n elif class_name == 'NutB':\\n color = (255, 144, 30) # DodgerBlue\\n elif class_name == 'NutC':\\n color = (180, 238, 180) # DarkSeaGreen2\\n elif class_name == 'WireA':\\n color = (255, 255, 255) # White\\n elif class_name == 'PlateA':\\n color = (0, 69, 255) # OrangeRed\\n elif class_name == 'PlateB':\\n color = (102, 205, 0) # SpringGreen3\\n elif class_name == 'PlateD':\\n color = (0, 255, 0) # Green\\n elif class_name == 'PlateE':\\n color = (0, 140, 250) # DarkOrange\\n elif class_name == 'BoltA':\\n color = (255, 255, 0) # Cyan\\n elif class_name == 'LoopB':\\n color = (180, 105, 255) # HotPink\\n elif class_name == 'JointA':\\n color = (105, 140, 255) # Salmon1\\n elif class_name == 'JointB':\\n color = (255, 0, 255) # Magenta3\\n elif class_name == 'FixatorA':\\n color = (0, 205, 102) # Chartreuse3\\n elif class_name == 'BearingA':\\n color = (185, 218, 255) # PeachPuff\\n elif class_name == 'PlugA':\\n color = (193, 193, 255) # RosyBrown1\\n else:\\n color = (139, 0, 139) # DarkMagenta\\n cv2.rectangle(im, bbox[0:2], bbox[2:4], color, 2)\\n # cv2.putText(im, '%s: %.3f' % (class_name, score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_COMPLEX,\\n # 0.5, color, thickness=1)\\n cv2.putText(im, '%s: %.3f' % (dict[class_name], score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_COMPLEX,\\n 0.5, color, thickness=1)\\n return im\",\n \"def detect(original_image, min_score, max_overlap, top_k, suppress=None):\\n\\n\\t# Transform\\n\\timage = normalize(to_tensor(resize(original_image)))\\n\\n\\t# Move to default device\\n\\timage = image.to(device)\\n\\n\\t# Forward prop.\\n\\tpredicted_locs, predicted_scores = model(image.unsqueeze(0))\\n\\n\\t# Detect objects in SSD output\\n\\tdet_boxes, det_labels, det_scores = model.detect_objects(predicted_locs, predicted_scores, min_score=min_score,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t max_overlap=max_overlap, top_k=top_k)\\n\\n\\t# Move detections to the CPU\\n\\tdet_boxes = det_boxes[0].to('cpu')\\n\\n\\t# Transform to original image dimensions\\n\\toriginal_dims = torch.FloatTensor(\\n\\t\\t[original_image.width, original_image.height, original_image.width, original_image.height]).unsqueeze(0)\\n\\tdet_boxes = det_boxes * original_dims\\n\\n\\t# Decode class integer labels\\n\\tdet_labels = [rev_label_map[l] for l in det_labels[0].to('cpu').tolist()]\\n\\n\\t# If no objects found, the detected labels will be set to ['0.'], i.e. ['background'] in SSD300.detect_objects() in model.py\\n\\tif det_labels == ['background']:\\n\\t\\t# Just return original image\\n\\t\\treturn original_image\\n\\n\\t# Annotate\\n\\tannotated_image = original_image\\n\\tdraw = ImageDraw.Draw(annotated_image)\\n\\tfont = ImageFont.truetype(\\\"./arial.ttf\\\", 15)\\n\\n\\t# Suppress specific classes, if needed\\n\\tfor i in range(det_boxes.size(0)):\\n\\t\\tif suppress is not None:\\n\\t\\t\\tif det_labels[i] in suppress:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t# Boxes\\n\\t\\tbox_location = det_boxes[i].tolist()\\n\\t\\tdraw.rectangle(xy=box_location, outline=label_color_map[det_labels[i]])\\n\\t\\tdraw.rectangle(xy=[l + 1. for l in box_location], outline=label_color_map[\\n\\t\\t\\tdet_labels[i]]) # a second rectangle at an offset of 1 pixel to increase line thickness\\n\\t\\t# draw.rectangle(xy=[l + 2. for l in box_location], outline=label_color_map[\\n\\t\\t# det_labels[i]]) # a third rectangle at an offset of 1 pixel to increase line thickness\\n\\t\\t# draw.rectangle(xy=[l + 3. for l in box_location], outline=label_color_map[\\n\\t\\t# det_labels[i]]) # a fourth rectangle at an offset of 1 pixel to increase line thickness\\n\\n\\t\\t# Text\\n\\t\\ttext_size = font.getsize(det_labels[i].upper())\\n\\t\\ttext_location = [box_location[0] + 2., box_location[1] - text_size[1]]\\n\\t\\ttextbox_location = [box_location[0], box_location[1] - text_size[1], box_location[0] + text_size[0] + 4.,\\n\\t\\t\\t\\t\\t\\t\\tbox_location[1]]\\n\\t\\tdraw.rectangle(xy=textbox_location, fill=label_color_map[det_labels[i]])\\n\\t\\tdraw.text(xy=text_location, text=det_labels[i].upper(), fill='white',\\n\\t\\t\\t\\t font=font)\\n\\tdel draw\\n\\n\\treturn annotated_image\",\n \"def apply_heuristics(obj_class: str, box_dimensions: list) -> list:\\n # RULE to crop pedestrian and car object regions\\n # Alter the box_dimensions in order to crop object regions based on class\\n left_point, top_point, box_width, box_height = box_dimensions # unpack box size\\n\\n # For vehicles, crop out the upper 50% - this should remove the window reflections\\n if obj_class in ['car', 'truck', 'bus']:\\n box_height = int(box_height // 2)\\n top_point = top_point + box_height\\n elif obj_class in ['person, bicycle', 'motorbike']:\\n # For pedestrians and bicycles, crop out the ground beneath them - the lower 20%\\n top_point = top_point + int(box_height // 5)\\n box_height = int(box_height // 1.25)\\n return [left_point, top_point, box_width, box_height]\",\n \"def demo(sess, net, image_name):\\n # Load the demo image\\n global CLASS_NAME\\n global CHECK\\n CHECK = 0\\n # 读取的截图所在的位置\\n # im_file = Cnn_path + \\\"data/VOCdevkit2007/VOC2007/JPEGImages/\\\" + image_name\\n curpath = os.path.dirname(os.path.realpath(__file__))\\n im_file = curpath + \\\"\\\\\\\\data\\\\\\\\VOCdevkit2007\\\\\\\\VOC2007\\\\\\\\JPEGImages\\\\\\\\\\\" + image_name\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, im)\\n timer.toc()\\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\\n\\n # Visualize detections for each class\\n # score 阈值，最后画出候选框时需要，>thresh才会被画出\\n CONF_THRESH = 0.5\\n # 非极大值抑制的阈值，剔除重复候选框\\n NMS_THRESH = 0.3\\n # 利用enumerate函数，获得CLASSES中 类别的下标cls_ind和类别名cls\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 # because we skipped background\\n # 取出bbox ,score\\n cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n # 将bbox,score 一起存入dets\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n # 进行非极大值抑制，得到抑制后的 dets\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n # 画框\\n vis_detections(im, cls, dets, thresh=CONF_THRESH)\\n if CHECK == 0:\\n CLASS_NAME = \\\"None\\\"\\n # im = im[:, :, (2, 1, 0)]\\n # fig, ax = plt.subplots()\\n # ax.imshow(im, aspect='equal')\\n # ax.set_title(\\\"None\\\",fontsize=10)\\n # plt.axis('off')\\n # plt.tight_layout()\\n # plt.draw()\\n # RES[INDS.__getitem__(image_name.split(\\\"_\\\")[0])][INDS.__getitem__(CLASS_NAME)]+=1\\n # plt.savefig(\\\"./output/\\\"+CLASS_NAME+\\\"_\\\" + image_name)\\n # plt.savefig(\\\"./output/\\\" + image_name)\\n MAX_SCORE[0] = 0.0\",\n \"def eval_pascal_one_class(pascal, detections, c):\\n gts = {} \\n num_objs = 0 \\n for img_name in pascal:\\n gts[img_name] = []\\n for obj in pascal[img_name]:\\n if obj['class_id'] == c and obj['difficult']==0:\\n gts[img_name] += [{'bbox':obj['bbox'], 'detected': False}]\\n num_objs += 1\\n\\n dts = []\\n scores = []\\n num_dets = 0\\n for img_name in detections:\\n for dt in detections[img_name]:\\n if dt['class_id'] == c:\\n dts.append([img_name, dt['bbox'], dt['score']])\\n scores.append(dt['score'])\\n num_dets += 1\\n \\n # Sort the detections based on their scores\\n scores = np.array(scores, np.float32)\\n sorted_idx = np.argsort(scores)[::-1]\\n\\n tp = np.zeros((num_dets))\\n fp = np.zeros((num_dets))\\n\\n for i in tqdm(list(range(num_dets))):\\n idx = sorted_idx[i]\\n img_name = dts[idx][0]\\n bbox = dts[idx][1] \\n gt_bboxes = np.array([obj['bbox'] for obj in gts[img_name]], np.float32) \\n\\n # Compute the max IoU of current detection with the ground truths\\n max_iou = 0.0\\n if gt_bboxes.size > 0:\\n ixmin = np.maximum(gt_bboxes[:, 0], bbox[0])\\n iymin = np.maximum(gt_bboxes[:, 1], bbox[1])\\n ixmax = np.minimum(gt_bboxes[:, 2], bbox[2])\\n iymax = np.minimum(gt_bboxes[:, 3], bbox[3])\\n\\n iw = np.maximum(ixmax - ixmin + 1.0, 0.0)\\n ih = np.maximum(iymax - iymin + 1.0, 0.0)\\n\\n area_intersect = iw * ih\\n area_union = (bbox[2] - bbox[0] + 1.0) * (bbox[3] - bbox[1] + 1.0) + (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1.0) * (gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1.0) - area_intersect\\n\\n ious = area_intersect / area_union\\n max_iou = np.max(ious, axis=0)\\n j = np.argmax(ious)\\n\\n # Determine if the current detection is a true or false positive\\n if max_iou > 0.5:\\n if not gts[img_name][j]['detected']:\\n tp[i] = 1.0\\n gts[img_name][j]['detected'] = True\\n else:\\n fp[i] = 1.0\\n else:\\n fp[i] = 1.0\\n\\n # Accumulate the numbers of true and false positives\\n tp = np.cumsum(tp)\\n fp = np.cumsum(fp)\\n\\n # Compute the average precision based on these data\\n rec = tp * 1.0 / num_objs\\n prec = tp * 1.0 / np.maximum((tp + fp), np.finfo(np.float64).eps)\\n\\n mrec = np.concatenate(([0.], rec, [1.]))\\n mpre = np.concatenate(([0.], prec, [0.]))\\n\\n for i in range(mpre.size - 1, 0, -1):\\n mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\\n\\n i = np.where(mrec[1:] != mrec[:-1])[0]\\n\\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\\n print('average precision for class %s = %f' %(pascal_class_names[c], ap))\\n\\n return ap\",\n \"def get_classification(self, image):\\n if self.correct_gamma:\\n if self.gamma == 1.0:\\n self.gamma = 0.6\\n elif self.gamma == 0.6:\\n self.gamma = 1.0\\n image = self.adjust_gamma(image, self.gamma)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n image_np = np.asarray(image, dtype=\\\"uint8\\\")\\n image_np_expanded = np.expand_dims(image_np, axis=0)\\n\\n detected = False\\n\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n boxes = np.squeeze(boxes)\\n classes = np.squeeze(classes).astype(np.int32)\\n scores = np.squeeze(scores)\\n best_scores = []\\n\\n for idx, classID in enumerate(classes):\\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\\n if classID == 10: # 10 is traffic light\\n if scores[idx] > 0.10: #confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n else: # we tuned the model to classify only traffic lights\\n if scores[idx] > 0.10: # confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n\\n tl_index = TrafficLight.UNKNOWN\\n if detected:\\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\\n\\n best_score = best_scores[0]\\n rospy.logdebug(\\\"number of TL found %d, best score: %f, color: %f\\\", len(best_scores), best_score[0], best_score[2])\\n nbox = boxes[best_score[1]]\\n\\n height = image.shape[0]\\n width = image.shape[1]\\n\\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\\n box_height = box[2] - box[0]\\n box_width = box[3] - box[1]\\n ratio = float(box_height)/float(box_width)\\n rospy.logdebug(\\\"ratio: %f\\\", ratio)\\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\\n tl_color, tl_index = self.get_color(tl_cropped)\\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\\n #tl_index = best_score[2]\\n #tl_color = color[tl_index]\\n #augment image with detected TLs\\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n font_color = (255, 255, 255)\\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\\n return image, tl_index\",\n \"def object_detect(filename):\\n cv2.ocl.setUseOpenCL(False)\\n just_fname = filename.split(\\\".\\\")[0]\\n image = cv2.imread('./static/uploads/' + filename)\\n bbox, label, conf = cv.detect_common_objects(image)\\n output_image = draw_bbox(image, bbox, label, conf)\\n plt.imshow(output_image)\\n plt.savefig(os.path.join('./static/output/', just_fname + '.png'))\\n d = Counter(label)\\n if not label:\\n return \\\"No objects detected\\\"\\n labelstr = \\\", \\\".join('{} {}'.format(v, k) for k, v in d.items())\\n return labelstr\",\n \"def __get_coco_masks(anns: list, img):\\n width = img.shape[1]\\n height = img.shape[0]\\n\\n if len(anns) == 0:\\n raise AnnError('Empty annotation detected.')\\n \\n classes = []\\n mask = np.zeros((height, width), dtype=np.int32)\\n \\n for inst_idx, ann in enumerate(anns):\\n cat_id = ann['category_id']\\n classes.append(cat_id)\\n\\n m = cocoseg_to_binary(ann['segmentation'], height, width) # zero one mask\\n m = m.astype(np.int32) * (inst_idx + 1)\\n mask[m > 0] = 255\\n\\n classes = np.asarray(classes)\\n return mask, classes\",\n \"def object_detection(self):\\r\\n pass\",\n \"def get_candidate_objects(output, img_size, classes, anchors, threshold):\\n\\n #threshold = 0.8\\n iou_threshold = 0.4\\n\\n boxes, probs = parse_yolo_output_v2(output, img_size, len(classes), anchors)\\n filter_mat_probs = (probs >= threshold)\\n filter_mat_boxes = np.nonzero(filter_mat_probs)[0:3]\\n boxes_filtered = boxes[filter_mat_boxes]\\n probs_filtered = probs[filter_mat_probs]\\n classes_num_filtered = np.argmax(probs, axis=3)[filter_mat_boxes]\\n\\n idx = np.argsort(probs_filtered)[::-1]\\n boxes_filtered = boxes_filtered[idx]\\n probs_filtered = probs_filtered[idx]\\n classes_num_filtered = classes_num_filtered[idx]\\n\\n # too many detections - exit\\n if len(boxes_filtered) > 1e3:\\n print(\\\"Too many detections, maybe an error? : {}\\\".format(\\n len(boxes_filtered)))\\n return []\\n\\n probs_filtered = non_maxima_suppression(boxes_filtered, probs_filtered,\\n classes_num_filtered, iou_threshold)\\n\\n filter_iou = (probs_filtered > 0.0)\\n boxes_filtered = boxes_filtered[filter_iou]\\n probs_filtered = probs_filtered[filter_iou]\\n classes_num_filtered = classes_num_filtered[filter_iou]\\n\\n result = []\\n for class_id, box, prob in zip(classes_num_filtered, boxes_filtered, probs_filtered):\\n result.append([classes[class_id], box[0], box[1], box[2], box[3], prob])\\n\\n return result\",\n \"def classify_face(im):\\n faces_death = get_encoded_faces_deaths()\\n faces_arrested = get_encoded_faces_arrested()\\n faces_wanted = get_encoded_faces_wanted()\\n\\n faces_encoded_death = list(faces_death.values())\\n known_face_names_death = list(faces_death.keys())\\n\\n faces_encoded_arrested = list(faces_arrested.values())\\n known_face_names_arrested = list(faces_arrested.keys())\\n\\n faces_encoded_wanted = list(faces_wanted.values())\\n known_face_names_wanted = list(faces_wanted.keys())\\n\\n img = cv2.imread(im, 1)\\n face_locations = face_recognition.face_locations(img)\\n unknown_face_encodings = face_recognition.face_encodings(img,face_locations)\\n face_names = []\\n find_in_db(im,known_face_names_death,unknown_face_encodings,face_names,faces_encoded_death,\\\"unnatural_death_images/unnatural_death_images\\\")\\n find_in_db(im,known_face_names_arrested,unknown_face_encodings,face_names,faces_encoded_arrested,\\\"ArrestPerson_images\\\")\\n find_in_db(im,known_face_names_wanted,unknown_face_encodings,face_names,faces_encoded_wanted,\\\"wanted\\\")\",\n \"def hog_extra_and_svm_class(proposal, clf, resize = (64, 64)):\\n img = cv2.cvtColor(proposal, cv2.COLOR_BGR2GRAY)\\n img = cv2.resize(img, resize)\\n bins = 9\\n cell_size = (8, 8)\\n cpb = (2, 2)\\n norm = \\\"L2\\\"\\n features = ft.hog(img, orientations=bins, pixels_per_cell=cell_size, \\n cells_per_block=cpb, block_norm=norm, transform_sqrt=True)\\n print \\\"feature = \\\", features.shape\\n features = np.reshape(features, (1,-1))\\n cls_prop = clf.predict_proba(features)\\n print(\\\"type = \\\", cls_prop)\\n print \\\"cls prop = \\\", cls_prop\\n return cls_prop\",\n \"def find_objects(image, **kw):\\n # This OpenCV based approach is MUCH slower:\\n # objects = list()\\n # for label in range(max_label+1 if max_label else amax(image)):\\n # mask = array(image==(label+1), uint8)\\n # if mask.any():\\n # x, y, w, h = cv2.boundingRect(mask)\\n # objects.append(sl.box(y,y+h,x,x+w))\\n # else:\\n # objects.append(None)\\n # return objects\\n try: return measurements.find_objects(image,**kw)\\n except: pass\\n types = [\\\"int32\\\",\\\"uint32\\\",\\\"int64\\\",\\\"uint64\\\",\\\"int16\\\",\\\"uint16\\\"]\\n for t in types:\\n try: return measurements.find_objects(array(image,dtype=t),**kw)\\n except: pass\\n # let it raise the same exception as before\\n return measurements.find_objects(image,**kw)\",\n \"def calculate_classifiers(self, segmented_image, grand_truth_image):\\n grand_truth_image = np.array(grand_truth_image)\\n\\n rows = grand_truth_image.shape[0]\\n cols = grand_truth_image.shape[1]\\n\\n global TP, FP, TN, FN, RN\\n\\n TP, FP, TN, FN, RN = 0, 0, 0, 0, 0\\n\\n # It calculates the classifers\\n for x in range(0, rows):\\n for y in range(0, cols):\\n\\n if grand_truth_image[x][y] == 255 and segmented_image[x][y] == 255:\\n TP += 1\\n elif grand_truth_image[x][y] == 0 and segmented_image[x][y] == 255:\\n FP += 1\\n elif grand_truth_image[x][y] == 0 and segmented_image[x][y] == 0:\\n TN += 1\\n elif grand_truth_image[x][y] == 255 and segmented_image[x][y] == 0:\\n FN += 1\\n else:\\n RN += 1\",\n \"def draw_pred(image: np.ndarray, class_name: str, box_dimensions: list, distance: float) -> None:\\n\\n # Params describes the amount of scaling in each of the rgb channels to produce a different color for each class\\n # The main object classes have different colours to make them easier to distinguish\\n params = {\\\"car\\\": (1, 0.85, 0.678), \\\"person\\\": (0, 0, 1), \\\"truck\\\": (0.33, 1, 0.5), \\\"bus\\\": (0.506, 0.149, 0.965)}\\n if class_name in params:\\n colour_scale = params[class_name] # get the colour values from the colour dictionary\\n else:\\n colour_scale = (0.90, 0.85, 0.678) # standard colour for less frequently occurring objects\\n\\n # Choose the brightness of the colour depending on distance away\\n # Objects that are further away have a darker shade of their class colour\\n # This gets brighter as the object gets closer - enables us to better visualise the depth predictions\\n tone = 255 - (min(distance, 50)/50)*255\\n colour = (tone * colour_scale[0], tone * colour_scale[1], tone * colour_scale[2])\\n\\n # Draw a bounding box.\\n left, top, box_width, height = box_dimensions # unpack the box tuple\\n cv2.rectangle(image, (left, top), (left + box_width, top + height), colour, 2)\\n object_label = ' %s : %.2fm' % (class_name, distance) # construct label\\n\\n # Display the label at the top of the bounding box\\n labelSize, baseLine = cv2.getTextSize(object_label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\\n top = max(top, labelSize[1])\\n cv2.rectangle(image, (left, top - round(1.5*labelSize[1])),\\n (left + round(1.5*labelSize[0]), top + baseLine), (255, 255, 255), cv2.FILLED)\\n cv2.rectangle(image, (left, top - round(1.5*labelSize[1])), (left + round(1.5*labelSize[0]), top + baseLine),\\n (0, 0, 0))\\n cv2.putText(image, object_label, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA)\",\n \"def detect_objects(self, pred_locs, pred_scores, min_score, max_overlap, top_k):\\n batch_size = pred_locs.size(0)\\n n_priors = self.priors_cxcy.size(0)\\n # Calculate softmax over class labels. (object vs background)\\n pred_scores = F.softmax(pred_scores, dim=2) # (N, 1930, 2)\\n\\n # Lists to store final predicted boxes, labels, and scores for all images\\n all_images_boxes = list()\\n all_images_labels = list()\\n all_images_scores = list()\\n\\n assert n_priors == pred_locs.size(1) == pred_scores.size(1)\\n\\n for i in range(batch_size):\\n # Decode object coordinates from the form we regressed predicted boxes to\\n # these are fractional point coordinates\\n decoded_locations = cxcy_to_xy(gcxgcy_to_cxcy(pred_locs[i], self.priors_cxcy)) # (1930, 4),\\n\\n # Lists to store boxes and scores for this image\\n image_boxes = list()\\n image_labels = list()\\n image_scores = list()\\n\\n # Keep object class scores where object is present, we need not calculate the score\\n # for background. This score is thresholded by minimum score\\n\\n object_class_scores = pred_scores[i][:, 1] # (1930)\\n score_above_min_score = object_class_scores > min_score # torch.bool\\n # number of box_prediction with good confidence score for object class\\n n_above_min_score = score_above_min_score.sum().item()\\n\\n # Pull the scores of object class above minimum scores\\n object_class_scores = object_class_scores[score_above_min_score] # (n_qualified)\\n # Pull decoded locations for the object class with qualified score\\n class_decoded_locs = decoded_locations[score_above_min_score] # (n_qualified, 4)\\n\\n # Sorting the predicted boxes and scores by object class scores\\n # (n_qualified), (n_min_score)\\n object_class_scores, sort_ind = object_class_scores.sort(dim=0, descending=True)\\n class_decoded_locs = class_decoded_locs[sort_ind] # (n_min_score, 4)\\n\\n # Find the overlap among predicted boxes\\n overlap = find_jaccard_overlap(class_decoded_locs, class_decoded_locs) # (n_qualified, n_min_score)\\n\\n # Non-Maximum Suppression (NMS)\\n # This technique is used to eliminate boxes which represent same object in the image\\n # Here we use suppress tensor to keep track of boxes which we need to supress\\n # Value of 1 means suppress and value of 0 means don't suppress\\n suppress = torch.zeros((n_above_min_score), dtype=torch.uint8).to(device) # (n_qualified)\\n\\n # Consider each box in order of decreasing scores\\n for box in range(class_decoded_locs.size(0)):\\n # If the box is already suppressed then continue\\n if suppress[box] == 1:\\n continue\\n\\n # Otherwise suppress boxes whose overlaps with this box, are greater than maximum overlap\\n # Find these boxes and update the suppress index\\n boxes_ovrlp_gthn_max_ovrlp = overlap[box] > max_overlap\\n boxes_ovrlp_gthn_max_ovrlp = torch.tensor(boxes_ovrlp_gthn_max_ovrlp, dtype=torch.uint8)\\n suppress = torch.max(suppress, boxes_ovrlp_gthn_max_ovrlp)\\n\\n # Don't suppress this box, even though it has an overlap of 1 with itself\\n suppress[box] = 0\\n\\n # Store only unsuppressed boxes for this class\\n image_boxes.append(class_decoded_locs[1 - suppress])\\n image_labels.append(torch.LongTensor((1 - suppress).sum().item() * [1]).to(device))\\n image_scores.append(object_class_scores[1 - suppress])\\n\\n # If the object is not present in the image, it is the 'background'\\n if len(image_boxes) == 0:\\n image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(device))\\n image_labels.append(torch.LongTensor([0]).to(device))\\n image_scores.append(torch.FloatTensor([0.]).to(device))\\n\\n # Concatenating all the objects in an image, into single tensor\\n image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4)\\n image_labels = torch.cat(image_labels, dim=0) # (n_objects)\\n image_scores = torch.cat(image_scores, dim=0) # (n_objects)\\n n_objects = image_scores.size(0)\\n\\n # Save only top_k confident objects\\n if n_objects > top_k:\\n image_scores, sort_ind = image_scores.sort(dim=0, descending=True)\\n image_scores = image_scores[:top_k] # (top_k)\\n image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4)\\n image_labels = image_labels[sort_ind][:top_k] # (top_k)\\n\\n # Append to lists that store predicted boxes and scores for all images\\n all_images_boxes.append(image_boxes)\\n all_images_labels.append(image_labels)\\n all_images_scores.append(image_scores)\\n\\n return all_images_boxes, all_images_labels, all_images_scores # lists of length batch_size\",\n \"def forward(sess, net, img, CONF_THRESH=0.8, NMS_THRESH=0.7):\\n\\n results = {'face': [],\\n 'lp': []}\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, img)\\n timer.toc()\\n\\n for cls in ('face', 'lp') :# enumerate(CLASSES[1:]):\\n cls_ind = CLASSES.index(cls) # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n results[cls] = [\\n [x0, y0, x1-x0, y1-y0] for (x0, y0, x1, y1, score) in dets[keep, :]]\\n\\n return results, timer.total_time\",\n \"def classify(self, image, nclasses, gamma):\\n\\n nclasses = nclasses + 1 # One extra class for the background\\n energy_sum = [1e-05]\\n\\n com = ConstantObservationModel()\\n icm = IteratedConditionalModes()\\n\\n if image.max() > 1:\\n image = np.interp(image, [0, image.max()], [0.0, 1.0])\\n\\n mu, sigma = com.initialize_param_uniform(image, nclasses)\\n p = np.argsort(mu)\\n mu = mu[p]\\n sigma = sigma[p]\\n sigmasq = sigma ** 2\\n\\n neglogl = com.negloglikelihood(image, mu, sigmasq, nclasses)\\n seg_init = icm.initialize_maximum_likelihood(neglogl)\\n\\n mu, sigma = com.seg_stats(image, seg_init, nclasses)\\n sigmasq = sigma ** 2\\n\\n zero = np.zeros_like(image) + 0.001\\n zero_noise = add_noise(zero, 10000, 1, noise_type='gaussian')\\n image_gauss = np.where(image == 0, zero_noise, image)\\n\\n final_segmentation = np.empty_like(image)\\n initial_segmentation = seg_init.copy()\\n\\n max_iter = 100\\n tolerance = 1e-05\\n\\n for i in range(max_iter):\\n\\n if self.verbose:\\n print('>> Iteration: ' + str(i))\\n\\n PLN = icm.prob_neighborhood(seg_init, beta, nclasses)\\n PVE = com.prob_image(image_gauss, nclasses, mu, sigmasq, PLN)\\n\\n mu_upd, sigmasq_upd = com.update_param(image_gauss,\\n PVE, mu, nclasses)\\n ind = np.argsort(mu_upd)\\n mu_upd = mu_upd[ind]\\n sigmasq_upd = sigmasq_upd[ind]\\n\\n negll = com.negloglikelihood(image_gauss, mu_upd, sigmasq_upd, nclasses)\\n final_segmentation, energy = icm.icm_ising(negll, beta, seg_init)\\n energy_sum.append(energy[energy > -np.inf].sum())\\n\\n if self.save_history:\\n self.segmentations.append(final_segmentation)\\n self.pves.append(PVE)\\n self.energies.append(energy)\\n self.energies_sum.append(energy[energy > -np.inf].sum())\\n\\n if i % 10 == 0 and i != 0:\\n\\n tol = tolerance * (np.amax(energy_sum) - np.amin(energy_sum))\\n\\n test_dist = np.absolute(np.amax(energy_sum[np.size(energy_sum) - 5: i]) -\\n np.amin(energy_sum[np.size(energy_sum) - 5: i]))\\n\\n if test_dist < tol:\\n\\n break\\n\\n seg_init = final_segmentation.copy()\\n mu = mu_upd.copy()\\n sigmasq = sigmasq_upd.copy()\\n\\n PVE = PVE[..., 1:]\\n\\n return initial_segmentation, final_segmentation, PVE\",\n \"def infer_classes(png_fname):\\n # 1 as speech\\n \\n from fastai.vision.image import open_image\\n classes = model_classes.predict(open_image(png_fname))\\n\\n return classes\",\n \"def image_classes():\\n\\n image_data_path = PROJECT_ROOT + \\\"/data/CUB_200_2011/\\\"\\n\\n # <class_id> <class_name>\\n classes = open(image_data_path + \\\"classes.txt\\\").readlines()\\n classes = [i.strip().split() for i in classes]\\n\\n # <image_id> <class_id>\\n labels = open(image_data_path + \\\"image_class_labels.txt\\\").readlines()\\n labels = [i.strip().split() for i in labels]\\n\\n class_ids = {}\\n for i in classes:\\n class_ids[i[1]] = int(i[0])\\n\\n label_ids = {}\\n for i in labels:\\n label_ids[int(i[0])] = int(i[1])\\n\\n return class_ids, label_ids\",\n \"def object_detector(detector, img_location: str, num_detection=5 ) -> list:\\n img = PIL.Image.open(img_location)\\n img = np.array(img)\\n img = tf.expand_dims(img, axis=0)\\n result = detector(img)\\n\\n ret = []\\n\\n for i in range(num_detection):\\n detection_class_number = int(result['detection_classes'].numpy()[0][i])\\n detection_class_name = CLASSES_90[detection_class_number]\\n\\n detection_score = result['detection_scores'].numpy()[0][i]\\n rounded_detection_score = round(float(detection_score), 2)\\n\\n # Append as a tuple\\n ret.append( (detection_class_name, rounded_detection_score) )\\n\\n return ret\",\n \"def visualize_detection(self, img, dets, classes=[], thresh=0.6):\\n import matplotlib.pyplot as plt\\n import random\\n plt.imshow(img)\\n height = img.shape[0]\\n width = img.shape[1]\\n colors = dict()\\n for det in dets:\\n (klass, score, x0, y0, x1, y1) = det\\n if score < thresh:\\n continue\\n cls_id = int(klass)\\n if cls_id not in colors:\\n colors[cls_id] = (random.random(), random.random(), random.random())\\n xmin = int(x0 * width)\\n ymin = int(y0 * height)\\n xmax = int(x1 * width)\\n ymax = int(y1 * height)\\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\\n ymax - ymin, fill=False,\\n edgecolor=colors[cls_id],\\n linewidth=3.5)\\n plt.gca().add_patch(rect)\\n class_name = str(cls_id)\\n if classes and len(classes) > cls_id:\\n class_name = classes[cls_id]\\n plt.gca().text(xmin, ymin - 2,\\n '{:s} {:.3f}'.format(class_name, score),\\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\\n fontsize=12, color='white')\\n plt.show()\",\n \"def get_classification(self, image):\\n\\n image_np_expanded = np.expand_dims(image, axis=0)\\n\\n # Perform network inference\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores,\\n self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n\\n if self.RUNNING_ON_CARLA == True:\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > .05:\\n if classes[i] == 10:\\n classname = self.category_index[classes[i]]['name']\\n print(classname, scores[i])\\n\\n # Extract image from best bounding box and pass through light classifier\\n ymin, xmin, ymax, xmax = boxes[i]\\n im_height, im_width, im_depth = image.shape\\n (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)\\n tf_image_cropped = image[int(top):int(bottom), int(left):int(right), :]\\n\\n PILImage = Image.fromarray(tf_image_cropped)\\n resized_img = PILImage.resize((85, 256), Image.ANTIALIAS)\\n image_np_resized = self.load_image_into_numpy_array(resized_img)\\n x = np.expand_dims(image_np_resized, axis=0)\\n x = np.vstack([x])\\n\\n #model = load_model('tf_classifier_1.h5')\\n #model.compile(loss='categorical_crossentropy',\\n # optimizer='adam',\\n # metrics=['accuracy'])\\n classes = self.keras_model.predict_classes(x, batch_size=1)\\n print(classes)\\n\\n if classes[0] == 0:\\n self.current_light = TrafficLight.GREEN\\n elif classes[0] == 2:\\n self.current_light = TrafficLight.YELLOW\\n else:\\n self.current_light = TrafficLight.RED\\n\\n break\\n\\n else:\\n # Check the detections. If it has a good score\\n # then set the current light to the detected label. The\\n # first one is always the best (they are returned sorted \\n # in score order).\\n # Note that we have trained for 14 categories, including\\n # left/right arrows etc. Here we are only looking for \\n # standard red, yellow and green light and ignore others.\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > .05:\\n classname = self.category_index[classes[i]]['name']\\n print(classname, scores[i])\\n\\n if classname == 'Green':\\n self.current_light = TrafficLight.GREEN\\n elif classname == 'Yellow':\\n self.current_light = TrafficLight.YELLOW\\n elif classname == 'Red':\\n self.current_light = TrafficLight.RED\\n else:\\n self.current_light = TrafficLight.UNKNOWN\\n\\n break\\n\\n return self.current_light\",\n \"def detect_from_img(self, img, up_sample=DEFAULT_UPSAMPLING):\\n # \\\"\\\"\\\"\\n # Args:\\n # img (numpy.ndarray): image loaded with scikit-image\\n # up_sample (int): integer to specifiy if we should perform upsampling (optional)\\n #\\n # Returns:\\n # detections (list): the detections as a list of dict with keys ``left``, ``top``, ``right``,\\n # ``bottom``, ``score``)\\n # \\\"\\\"\\\"\\n raise NotImplementedError('detect_from_img')\",\n \"def my_evaluate(original_image, img_id, annotations, min_score=0.4, max_overlap=0.3, top_k=200):\\n\\n # Transform\\n image = normalize(to_tensor(resize(original_image)))\\n\\n # Move to default device\\n image = image.to(device)\\n\\n # Forward prop.\\n predicted_locs, predicted_scores = model(image.unsqueeze(0))\\n\\n # Detect objects in SSD output\\n det_boxes, det_labels, det_scores = model.detect_objects(predicted_locs, predicted_scores, min_score=min_score,\\n max_overlap=max_overlap, top_k=top_k)\\n\\n # Move detections to the CPU\\n det_boxes = det_boxes[0].to('cpu')\\n\\n # Transform to original image dimensions\\n original_dims = torch.FloatTensor(\\n [original_image.width, original_image.height, original_image.width, original_image.height]).unsqueeze(0)\\n det_boxes = det_boxes * original_dims\\n\\n # Decode class integer labels\\n det_labels = [rev_label_map[l] for l in det_labels[0].to('cpu').tolist()]\\n det_scores = det_scores[0].to('cpu').tolist()\\n\\n if det_labels != ['background']:\\n for i in range(det_boxes.size(0)):\\n \\n # For every detection, see whether it matches a ground truth\\n match = False\\n for j in range(len(annotations['boxes'])):\\n if annotations['labels'][j] == -1: # this is being set when a ground truth already matched\\n continue\\n match = box_match(det_boxes[i], \\n det_labels[i], \\n torch.Tensor(annotations['boxes'][j]), \\n rev_label_map[annotations['labels'][j]])\\n if match:\\n annotations['labels'][j] = -1\\n break\\n \\n if match: # true positive if the detection is correct and matched a ground truth\\n all_results['true_positive'] += 1\\n else: # false positive if the detection did not match a ground truth\\n all_results['false_positive'] += 1\\n \\n # After all detections were checked, let us see whether the detector missed something\\n for label in annotations['labels']: \\n if label == -1: # This is set after a detection matched this ground truth\\n continue\\n \\n # false negative if we reach this line, since the ground truth object was not found\\n all_results['false_negative'] += 1\",\n \"def demo(sess, net, image_name):\\n\\n # Load the demo image\\n im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\\n #im_file = os.path.join('/home/corgi/Lab/label/pos_frame/ACCV/training/000001/',image_name)\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, im)\\n timer.toc()\\n print (('Detection took {:.3f}s for '\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0]))\\n\\n # Visualize detections for each class\\n im = im[:, :, (2, 1, 0)]\\n fig, ax = plt.subplots(figsize=(12, 12))\\n ax.imshow(im, aspect='equal')\\n\\n CONF_THRESH = 0.8\\n NMS_THRESH = 0.3\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n vis_detections(im, cls, dets, ax, thresh=CONF_THRESH)\",\n \"def classify_face(im):\\r\\n faces = get_encoded_faces()\\r\\n faces_encoded = list(faces.values())\\r\\n known_face_names = list(faces.keys())\\r\\n\\r\\n img = cv2.imread(im, 1)\\r\\n \\\"\\\"\\\"\\r\\n Resize optinal \\r\\n \\\"\\\"\\\"\\r\\n #img = cv2.resize(img, (0, 0), fx=0.5, fy=0.5)\\r\\n #img = img[:,:,::-1]\\r\\n face_locations = face_recognition.face_locations(img)\\r\\n unknown_face_encodings = face_recognition.face_encodings(img, face_locations)\\r\\n\\r\\n face_names = []\\r\\n for face_encoding in unknown_face_encodings:\\r\\n # See if the face is a match for the known face(s)\\r\\n matches = face_recognition.compare_faces(faces_encoded, face_encoding)\\r\\n name = \\\"Unknown\\\"\\r\\n\\r\\n # use the known face with the smallest distance to the new face\\r\\n face_distances = face_recognition.face_distance(faces_encoded, face_encoding)\\r\\n best_match_index = np.argmin(face_distances)\\r\\n if matches[best_match_index]:\\r\\n name = known_face_names[best_match_index]\\r\\n\\r\\n face_names.append(name)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n All the photo lables in the faces foler end with (number) so a simiple .find(\\\"(\\\") command takes the () away from\\r\\n the label leaving us with the full name of the person\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n result = name.find('(') \\r\\n fullname = (name[:result])\\r\\n \\\"\\\"\\\"\\r\\n If face_recogntion module recognizes a face but that face is not in the faces module then \\r\\n it will print unknown and we print 12345678 to use it on the start attednace program \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n if (name == \\\"Unknown\\\"):\\r\\n print(\\\"12345678\\\")\\r\\n else:\\r\\n \\\"\\\"\\\"\\r\\n f'{len(face_locayion)}-people - will return the number of people in photo taken by Nao'\\r\\n \\\"\\\"\\\"\\r\\n print (f'{len(face_locations)}-people')\\r\\n print (fullname)\\r\\n print(courseid)\\r\\n print (lateornot)\\r\\n c34 = fullname.find(' ')\\r\\n firstname = (fullname[:c34])\\r\\n lastname = (fullname[c34:])\\r\\n \\\"\\\"\\\"\\r\\n We get all the data courseid , fristname , lastname, datetime1,and late or not and submited on the website \\r\\n \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n login_data = {\\r\\n\\t 'Course': courseid,\\r\\n\\t 'FirstName': firstname,\\r\\n\\t 'LastName': lastname,\\r\\n\\t 'Date': datetime2,\\r\\n\\t 'Attendance': 'on',\\r\\n\\t 'Late': latev,\\r\\n\\t 'submitbutton': 'Submit'\\r\\n }\\r\\n if(fullname == \\\"Unknow\\\"):\\r\\n \\tprint(\\\"I-dont-know-you\\\")\\r\\n else:\\r\\n \\r\\n with requests.Session() as s:\\r\\n \\turl = \\\"https://rbattendance.000webhostapp.com/update.php\\\"\\r\\n \\tr = s.get(url)\\r\\n \\tsoup = BeautifulSoup(r.content, 'html5lib')\\r\\n \\tr = s.post(url, data = login_data)\\r\\n \\t#print(r.content)\\r\\n \\r\\n \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n This for loop is reponsible for drawing on the image \\r\\n \\\"\\\"\\\"\\r\\n\\r\\n for (top, right, bottom, left), name in zip(face_locations, face_names):\\r\\n # Draw a box around the face\\r\\n cv2.rectangle(img, (left-20, top-20), (right+20, bottom+20), (255, 0, 0), 2)\\r\\n\\r\\n # Draw a label with a name below the face\\r\\n cv2.rectangle(img, (left-20, bottom -15), (right+20, bottom+20), (255, 0, 0), cv2.FILLED)\\r\\n font = cv2.FONT_HERSHEY_DUPLEX\\r\\n cv2.putText(img, name, (left -20, bottom + 15), font, 1.0, (255, 255, 255), 2)\\r\\n\\r\\n\\r\\n # Display the resulting image\\r\\n \\r\\n \\r\\n while True:\\r\\n #cv2.imshow('Video', img)\\r\\n #if cv2.waitKey(1) & 0xFF == ord('q'):\\r\\n return face_names\",\n \"def classify_face(img, HOG_model):\\r\\n img = pp.resize_image(img, img_input_size)\\r\\n \\r\\n # Ensure shape matches exactly\\r\\n shape_delta = img_input_shape[0] - img.shape[0]\\r\\n if shape_delta > 0:\\r\\n new_row = np.random.randint(0,255,[shape_delta,img_input_shape[1],img_input_shape[2]],dtype='uint8')\\r\\n img = np.vstack([img, new_row])\\r\\n \\r\\n elif shape_delta < 0:\\r\\n img = img[:img_input_shape[0],:,:] \\r\\n \\r\\n HOG_img = HOG_extractor(img).flatten()\\r\\n class_pred = img_classes[HOG_model.predict_proba([HOG_img]).argmax(axis=-1)[0]]\\r\\n return class_pred\",\n \"def find_colours(self, img, colour, num_objects=1, ab_dist_thresh=50):\\n img_lab = cv2.cvtColor(img,cv2.COLOR_BGR2LAB) #convert to LAB colour space \\n img_a = img_lab[:,:,1] #A compononent of image\\n img_b = img_lab[:,:,2] #B compononent of image \\n des_a = colour[1] #A component of desired colour\\n des_b = colour[2] #B component of desired colour\\n \\n #Compute difference between desired components and actual components\\n d_a = img_a - des_a\\n d_b = img_b - des_b\\n dist_squared = d_a**2 + d_b**2\\n \\n #Apply threshold\\n img_bin = np.uint8(dist_squared<ab_dist_thresh)*255\\n \\n #do connected components analysis to find centroids of large connected objects\\n conn_comp = cv2.connectedComponentsWithStats(img_bin, 8, cv2.CV_32S)\\n\\n #sort by area, from largest to smallest\\n areas = np.int_(conn_comp[2][:,4])\\n idx = areas.argsort()\\n idx = idx[::-1]\\n centroids = np.int_(conn_comp[3])\\n centroids = centroids[idx[1:num_objects+1]]\\n \\n #if more than one object returned, order from left to right\\n idx = centroids[:,0].argsort() #sort by x value\\n centroids = list(centroids[idx])\\n \\n #return centroid position and binary image of detected objects\\n if len(centroids) == 1:\\n return centroids[0], img_bin\\n else:\\n return centroids, img_bin\",\n \"def get_classification(self, image, wp = 0):\\n\\n cv2_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) \\n input_image = np.expand_dims(cv2_image, axis=0)\\n (boxes, scores, classes) = self.sess.run([self.boxes, self.scores, self.classes], \\n feed_dict={self.image_tensor: input_image})\\n\\n prediction = 4\\n min_score_thresh=.6\\n sq_boxes = np.squeeze(boxes)\\n sq_classes = np.squeeze(classes).astype(np.int32)\\n sq_scores = np.squeeze(scores)\\n\\n for i in range(sq_boxes.shape[0]):\\n if sq_scores is None or sq_scores[i] > min_score_thresh:\\n prediction = sq_classes[i]\\n min_score_thresh = sq_scores[i]\\n print(\\\"Found traffic light: {i:%d prediction:%s pred_score:%.4f}\\\"%(i, prediction, sq_scores[i]))\\n \\n if prediction == 1:\\n return TrafficLight.RED\\n elif prediction == 2:\\n return TrafficLight.YELLOW\\n elif prediction == 3:\\n return TrafficLight.GREEN\\n return TrafficLight.UNKNOWN\",\n \"def _get_class(self, obj):\\n\\n object_type = obj.object_type\\n\\n 'Background class'\\n object_class = 0\\n\\n # Don't care classes\\n if object_type in ['DontCare', 'Person_sitting'] or obj.truncation > 0.75 or obj.occlusion > 1:\\n object_class = 1\\n\\n # Vehicle classes\\n elif object_type in ['Car', 'Van']:\\n object_class = 2\\n\\n # Pedestrian class\\n elif object_type in ['Pedestrian']: # TODO: Consider change this with ==\\n object_class = 3\\n\\n # Cyclist class\\n elif object_type in ['Cyclist']: # TODO: Consider change this with ==\\n object_class = 4\\n\\n return object_class\",\n \"def detect_objects(self, image, threshold=0.5, needs_preprocessing=False, temp_path='temp.jpg'):\\n if cv2 is None:\\n raise Exception(\\\"OpenCV is not installed.\\\")\\n cv2.imwrite(temp_path, image)\\n url = 'http://{}/endpoints/{}/model/{}/v{}/detectobjects'.format(\\n self.skil.config.host,\\n self.deployment.name,\\n self.model.name,\\n self.model.version\\n )\\n\\n # TODO: use the official \\\"detectobject\\\" client API, once fixed in skil_client\\n # print(\\\">>>> TEST\\\")\\n # resp = self.skil.api.detectobjects(\\n # id='foo',\\n # needs_preprocessing=False,\\n # threshold='0.5',\\n # image_file=temp_path,\\n # deployment_name=self.model.deployment.name,\\n # version_name='default',\\n # model_name=self.model.name\\n # )\\n\\n with open(temp_path, 'rb') as data:\\n resp = requests.post(\\n # TODO: should also have a model \\\"version\\\"?\\n url=url,\\n headers=self.skil.auth_headers,\\n files={\\n 'file': (temp_path, data, 'image/jpeg')\\n },\\n data={\\n 'id': self.model.id,\\n 'needs_preprocessing': 'true' if needs_preprocessing else 'false',\\n 'threshold': str(threshold)\\n }\\n )\\n if os.path.isfile(temp_path):\\n os.remove(temp_path)\\n\\n return resp.json()\",\n \"def vis_detections(color_image, depth_colormap, class_col, dets_col, thresh=0.5):\\n\\n for cls_ind, class_name in enumerate(class_col):\\n dets = dets_col[cls_ind]\\n\\n inds = np.where(dets[:, -1] >= thresh)[0]\\n if len(inds) == 0:\\n continue\\n\\n for i in inds:\\n bbox = [int(e) for e in dets[i, :4]]\\n score = dets[i, -1]\\n \\n cv2.rectangle(color_image, (bbox[0], bbox[1]),\\n (bbox[2], bbox[3]), (0, 0, 255), 3)\\n cv2.rectangle(depth_colormap, (bbox[0], bbox[1]),\\n (bbox[2], bbox[3]), (0, 0, 255), 3)\\n\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n color_image = cv2.putText(color_image, '{:s} {:.3f}'.format(class_name, score),\\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\\n depth_colormap = cv2.putText(depth_colormap, '{:s} {:.3f}'.format(class_name, score),\\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\\n \\n # Stack both images horizontally\\n images = np.hstack((color_image, depth_colormap))\\n\\n # Show images\\n cv2.imshow('RealSense', images)\",\n \"def demo(net, image_name, conf_thres, nms_thres, resDir, bShow=False):\\n global CLASSES\\n\\n # Load the demo image\\n im_file = image_name\\n im = cv2.imread(im_file)\\n fname = os.path.basename(image_name)\\n\\n # Detect all object classes and regress object bounds\\n # timers\\n _t = {'im_detect' : Timer(), 'misc' : Timer(), 'save' : Timer()}\\n\\n _t['im_detect'].tic()\\n scores, boxes = im_detect(net, im)\\n _t['im_detect'].toc()\\n \\n \\n _t['misc'].tic() \\n results = np.zeros((0, 6), dtype=np.float32)\\n # Visualize detections for each class\\n # for cls_ind, cls in enumerate(CLASSES[1:5]):\\n for cls_ind, cls in enumerate(CLASSES[1:]): \\n cls_ind += 1 # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n \\n # CPU NMS is much faster than GPU NMS when the number of boxes\\n # is relative small (e.g., < 10k)\\n # TODO(rbg): autotune NMS dispatch\\n keep = nms(dets, nms_thres, force_cpu=True)\\n dets = dets[keep, :]\\n results = np.vstack( (results, np.insert(dets, 0, cls_ind, axis=1)) ) \\n _t['misc'].toc() \\n \\n if bShow:\\n plt.figure(1, figsize=(15,10))\\n plt.clf()\\n axe = plt.gca()\\n axe.imshow(im[:,:,(2,1,0)])\\n\\n clrs = sns.color_palette(\\\"Set2\\\", len(CLASSES))\\n for det in results:\\n cls_ind, box, score = det[0], det[1:5], det[5]\\n if score < 0.8: continue\\n clr = clrs[int(cls_ind)]\\n rect = plt.Rectangle( (box[0], box[1]), box[2]-box[0], box[3]-box[1], fill=False, edgecolor=clr, linewidth=2.5)\\n axe.add_patch(rect)\\n axe.text(box[0], box[1]-2, '{:.3f}'.format(score), bbox=dict(facecolor=clr, alpha=0.5), fontsize=14, color='white')\\n\\n axe.axis('off')\\n save_name = os.path.basename(im_file)\\n plt.savefig('[DEMO]'+save_name, dpi=200) \\n\\n else:\\n _t['save'].tic()\\n with open( os.path.join(resDir, fname.split('.')[0] + '.txt'), 'w') as fp: \\n for det in results:\\n if len(det) == 0: continue \\n if det[5] < 0.01: continue\\n\\n resStr = '{:s} -1 -1 -10 '.format(CLASSES[int(det[0])]) \\n resStr += '{:.2f} {:.2f} {:.2f} {:.2f} '.format(det[1],det[2],det[3],det[4]) # x1 y1 x2 y2\\n resStr += '-1 -1 -1 -1000 -1000 -1000 -10 {:.4f}\\\\n'.format(det[5])\\n fp.write( resStr ) \\n _t['save'].toc()\\n\\n return _t\",\n \"def find_objects(img, threshold=.3):\\n thresholded_img = np.uint8(img > threshold)\\n _, markers = cv2.connectedComponents(thresholded_img)\\n object_centers = []\\n for ii in range(1, np.max(markers)):\\n masked_img = mask_img(img, markers == ii)\\n object_index = np.argmax(masked_img)\\n object_center = np.unravel_index(object_index, img.shape)\\n object_centers.append(object_center)\\n return np.array(object_centers)\",\n \"def get_classification(self, image):\\n\\n temp = cv2.cvtColor(cv2.GaussianBlur(image,(5,5),0), cv2.COLOR_BGR2HSV)\\n\\n maskR = cv2.inRange(temp, np.array([0, 195, 240]), np.array([5, 215, 255]))\\n maskY = cv2.inRange(temp, np.array([28, 195, 240]), np.array([35, 215, 255]))\\n maskG = cv2.inRange(temp, np.array([60, 195, 240]), np.array([67, 215, 255]))\\n\\n filt_r = cv2.bitwise_and(temp,temp, mask= maskR)\\n filt_y = cv2.bitwise_and(temp,temp, mask= maskY)\\n filt_g = cv2.bitwise_and(temp,temp, mask= maskG)\\n\\n # Bitwise-AND mask and original image\\n self.debug_im1 = filt_r\\n self.debug_im2 = filt_y\\n self.debug_im3 = filt_g\\n status = TrafficLight.UNKNOWN\\n\\n if np.sum(maskR>10):\\n print('detected red')\\n status = TrafficLight.RED\\n elif np.sum(maskY>10):\\n print('detected yellow')\\n status = TrafficLight.YELLOW\\n elif np.sum(maskG>10):\\n print('detected green')\\n status = TrafficLight.GREEN\\n\\n # self.debug()\\n return status\",\n \"def determineClasses(self, particles):\\n\\t\\tapDisplay.printMsg(\\\"sorting refineparticledata into classes\\\")\\n\\t\\tt0 = time.time()\\n\\t\\tclasses={}\\n\\t\\tclass_stats={}\\n\\t\\tquality=numpy.zeros(len(particles))\\n\\t\\tfor partnum in range(len(particles)):\\n\\t\\t\\tquality[partnum] = particles[partnum]['quality_factor']\\n\\t\\t\\tkey = (\\\"%.3f_%.3f\\\"%(particles[partnum]['euler1'], particles[partnum]['euler2']))\\n\\t\\t\\tif key not in classes.keys():\\n\\t\\t\\t\\tclasses[key]={}\\n\\t\\t\\t\\tclasses[key]['particles']=[]\\n\\t\\t\\t\\tclasses[key]['euler1'] = particles[partnum]['euler1']\\n\\t\\t\\t\\tclasses[key]['euler2'] = particles[partnum]['euler2']\\n\\t\\t\\t\\t#classes have no inplane rotation\\n\\t\\t\\t\\tclasses[key]['euler3'] = 0.0 #particles[partnum]['euler3']\\n\\t\\t\\tclasses[key]['particles'].append(particles[partnum])\\n\\t\\tclass_stats['meanquality']=quality.mean()\\n\\t\\tclass_stats['stdquality']=quality.std()\\n\\t\\tclass_stats['max']=quality.max()\\n\\t\\tclass_stats['min']=quality.min()\\n\\t\\tapDisplay.printMsg(\\\"sorted %d particles into %d classes\\\"%(len(particles), len(classes)))\\n\\t\\t### print stats\\n\\t\\tprint \\\"-- quality factor stats --\\\"\\n\\t\\tprint (\\\"mean/std :: \\\"+str(round(class_stats['meanquality'],2))+\\\" +/- \\\"\\n\\t\\t\\t+str(round(class_stats['stdquality'],2)))\\n\\t\\tprint (\\\"min/max :: \\\"+str(round(class_stats['min'],2))+\\\" <> \\\"\\n\\t\\t\\t+str(round(class_stats['max'],2)))\\n\\t\\tapDisplay.printMsg(\\\"finished sorting in \\\"+apDisplay.timeString(time.time()-t0))\\n\\t\\treturn classes, class_stats\",\n \"def classif(self, text):\\r\\n content = self.prizn.tokenize(text)\\r\\n filec = self.vectorize_content(content)\\r\\n selected = {}\\r\\n for klas in self.prizn.klas_tridy:\\r\\n distance = 0.0\\r\\n wrdc = 0.0\\r\\n for wrd in filec:\\r\\n if wrd in self.prizn.klas_tridy[klas]:\\r\\n wrdc += 1.0\\r\\n distance += abs(float(filec[wrd]) - float(self.prizn.klas_tridy[klas][wrd]))\\r\\n if wrdc > 0:\\r\\n selected[klas] = float(distance) / float(wrdc)\\r\\n\\r\\n max_class = \\\"\\\"\\r\\n for i in range(0, 3):\\r\\n klas = max(selected, key=lambda k: selected[k])\\r\\n max_class = max_class + \\\" ,\\\" + klas\\r\\n del selected[klas]\\r\\n\\r\\n return max_class\",\n \"def runClassifier(interpreter, image, threshold):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n count = int(get_output_tensor(interpreter, 3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= threshold:\\n result = {\\n \\\"bounding_box\\\": boxes[i],\\n \\\"class_id\\\": classes[i],\\n \\\"score\\\": scores[i],\\n }\\n results.append(result)\\n return results\",\n \"def get_object(self, img):\\n objectType = 'none'\\n colourProb = np.ones((3,)) / 3.0\\n distance = 0.0\\n angle = 0.0\\n self.patternFound = False\\n \\n #patternFound, corners = self.get_corners(img)\\n self.get_corners(img)\\n \\n if (self.patternFound):\\n \\n # Determine if the object is horizontal or vertical\\n delta_x = abs(self.corners[0,0,0] - self.corners[2,0,0])\\n delta_y = abs(self.corners[0,0,1] - self.corners[2,0,1])\\n horizontal = (delta_y > delta_x)\\n if (horizontal):\\n objectType = 'horizontal'\\n else:\\n objectType = 'vertical'\\n \\n # Compute distances and angles\\n if (horizontal):\\n height = ((abs (self.corners [0,0,1] - self.corners [2,0,1]) +\\n abs (self.corners [9,0,1] - self.corners [11,0,1])) / 2.0);\\n \\n patternHeight = (self.patternSize[0]-1.0) * self.patternUnit\\n \\n else:\\n height = (abs (self.corners [0,0,1] - self.corners [9,0,1]) +\\n abs (self.corners [2,0,1] - self.corners [11,0,1])) / 2.0;\\n \\n patternHeight = (self.patternSize[1]-1.0) * self.patternUnit\\n \\n #distance = 1.0 / (0.0001 * height);\\n distance = self.intrinsic_matrix[1,1] * patternHeight / (height * 10.0) \\n\\n center = (self.corners [0,0,0] + self.corners [2,0,0] +\\n self.corners [9,0,0] + self.corners [11,0,0]) / 4.0;\\n \\n #angle = 0.0018 * center - 0.6425;\\n #angle *= -1.0;\\n angle = -np.arctan2(center - self.intrinsic_matrix[0,2], self.intrinsic_matrix[0,0])\\n \\n \\n #### Classify object by colour\\n \\n # Extract rectangle corners\\n points = np.array(\\n [self.corners [0],\\n self.corners [2],\\n self.corners [9],\\n self.corners [11]]\\n )\\n \\n points.shape = (4,2)\\n points = np.int32(points)\\n\\n # Compute region of interest\\n mask = np.zeros((self.imageSize[1], self.imageSize[0]), dtype =np.uint8) \\n cv2.fillConvexPoly (mask, points, (255, 255, 255)) \\n \\n # Compute mean colour inside region of interest\\n mean_colour = cv2.mean(img, mask);\\n \\n red = mean_colour[2];\\n green = mean_colour[1];\\n blue = mean_colour[0];\\n sum = red + green + blue;\\n\\n colourProb[0] = red / sum;\\n colourProb[1] = green / sum;\\n colourProb[2] = blue / sum;\\n \\n \\n return objectType, distance, angle, colourProb\",\n \"def checkout_findings(pseudo, conf, show=True):\\n ### Create images with label names\\n class_label_img = []\\n# font_path = '/usr/share/fonts/truetype/ubuntu/UbuntuMono-B.ttf'\\n font_path = '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf'\\n img_width = 512\\n font_size = int(img_width*0.14) #hypkva 15\\n letters_per_line = 12 #hypkva 13\\n\\n for i in range(conf[\\\"num_classes\\\"]):\\n img = Image.new('RGB', (img_width, img_width), color = (0, 0, 0))\\n fnt = ImageFont.truetype(font_path, font_size)\\n d = ImageDraw.Draw(img)\\n if (len(conf[\\\"class_names\\\"][i])>letters_per_line):\\n text = textwrap.fill(conf[\\\"class_names\\\"][i], width=letters_per_line)\\n else:\\n text = conf[\\\"class_names\\\"][i]\\n linebreaks = text.count('\\\\n')\\n d.text((1,(img_width//2.2)-linebreaks*img_width*0.1), text, font=fnt, fill=(255, 255, 255))\\n\\n class_label_img.append(img)\\n \\n ### Create a list with 6 samples per class\\n # black image\\n img_black = Image.new('RGB', (conf[\\\"img_shape\\\"][0], conf[\\\"img_shape\\\"][1]), color = (0, 0, 0))\\n \\n lab_arr = np.asarray(pseudo[\\\"lab_list\\\"], dtype=np.uint8)\\n class_examples = []\\n class_preds = []\\n for class_idx in range(conf[\\\"num_classes\\\"]):\\n curr_class_examples = []\\n curr_class_preds = []\\n\\n indekser = np.where(lab_arr==class_idx)[0]\\n for i in range(6):\\n # get 6 finding images from class_idx-class\\n # no image - index out of bounds\\n if not indekser.size > i:\\n curr_class_examples.append(img_black)\\n curr_class_preds.append(0)\\n # found image\\n else:\\n fn = pseudo[\\\"name_list\\\"][indekser[i]]\\n img = fn2img(fn, conf[\\\"unlab_dir\\\"], img_width)\\n \\n curr_class_examples.append(img)\\n curr_class_preds.append(pseudo[\\\"pred_list\\\"][indekser[i]])\\n\\n class_examples.append(curr_class_examples)\\n class_preds.append(curr_class_preds)\\n\\n assert (len(conf[\\\"class_names\\\"])==len(class_examples)), 'must be same length'\\n \\n ### Display the predicted images in each class\\n # settings\\n nrows, ncols = conf[\\\"num_classes\\\"], 7 # array of sub-plots\\n figsize = [ncols*3, conf[\\\"num_classes\\\"]*3] # figure size, inches\\n\\n # create figure (fig), and array of axes (ax)\\n fig, ax = plt.subplots(nrows=nrows, ncols=ncols, \\n figsize=figsize, frameon=False, facecolor='white')\\n\\n # plot simple raster image on each sub-plot\\n for i, axi in enumerate(ax.flat):\\n # i runs from 0 to (nrows*ncols-1)\\n # axi is equivalent with ax[rowid][colid]\\n rowid = i // ncols\\n colid = i % ncols\\n\\n if colid == 0:\\n img = class_label_img[rowid]\\n else:\\n pred = class_preds[rowid][colid-1]\\n title = \\\"conf: \\\"+str(round(pred, 3))\\n if pred: axi.set_title(title)\\n img = class_examples[rowid][colid-1]\\n \\n axi.imshow(img)\\n axi.set_axis_off()\\n\\n plt.axis('off')\\n plt.tight_layout(True)\\n plt.savefig(\\\"{}/checkout-all.pdf\\\".format(conf[\\\"log_dir\\\"]), format='pdf')\\n if show:\\n plt.show()\\n else:\\n plt.close()\",\n \"def classify_image_probavec(image, model, image_box=None):\\n images_list = []\\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\\n # box argument clips image to (x1, y1, x2, y2)\\n image = np.array(image)\\n images_list.append(image)\\n \\n return model.predict(np.array(images_list))\",\n \"def on_object(self, image, objects):\\n for obj in objects:\\n if self.is_object_recognition_appropriate(obj.name):\\n self.say(\\\"I see a {}\\\".format(obj.name))\",\n \"def detect_all_objects(gray, haar_file, params, verbose=False):\\n # Not the most performant to load haar_cascade for each image when params aren't changing...\\n haar_cascade = cv.CascadeClassifier(haar_file)\\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\\n if verbose:\\n print(f\\\"# of Objects Detected = {len(detected_objects)}\\\")\\n return detected_objects\",\n \"def compute_precision_recall_bbox(per_image_detections, per_image_gts, num_gt_classes,\\n matching_iou_threshold=0.5):\\n per_image_eval = per_image_evaluation.PerImageEvaluation(\\n num_groundtruth_classes=num_gt_classes,\\n matching_iou_threshold=matching_iou_threshold,\\n nms_iou_threshold=1.0,\\n nms_max_output_boxes=10000\\n )\\n\\n print('Running per-object analysis...')\\n\\n detection_tp_fp = defaultdict(list) # key is the category; in each list, 1 is tp, 0 is fp\\n detection_scores = defaultdict(list)\\n num_total_gt = defaultdict(int)\\n\\n for image_id, dets in tqdm(per_image_detections.items()):\\n\\n detected_boxes = np.array(dets['boxes'], dtype=np.float32)\\n detected_scores = np.array(dets['scores'], dtype=np.float32)\\n # labels input to compute_object_detection_metrics() needs to start at 0, not 1\\n detected_labels = np.array(dets['labels'], dtype=np.int) - 1 # start at 0\\n # num_detections = len(dets['boxes'])\\n\\n gts = per_image_gts[image_id]\\n gt_boxes = np.array(gts['gt_boxes'], dtype=np.float32)\\n gt_labels = np.array(gts['gt_labels'], dtype=np.int) - 1 # start at 0\\n num_gts = len(gts['gt_boxes'])\\n\\n groundtruth_is_difficult_list = np.zeros(num_gts, dtype=bool) # place holders - we don't have these\\n groundtruth_is_group_of_list = np.zeros(num_gts, dtype=bool)\\n\\n # to prevent 'Invalid dimensions for box data.' error\\n if num_gts == 0:\\n # this box will not match any detections\\n gt_boxes = np.array([[0, 0, 0, 0]], dtype=np.float32)\\n\\n scores, tp_fp_labels, is_class_correctly_detected_in_image = (\\n per_image_eval.compute_object_detection_metrics(\\n detected_boxes=detected_boxes,\\n detected_scores=detected_scores,\\n detected_class_labels=detected_labels,\\n groundtruth_boxes=gt_boxes,\\n groundtruth_class_labels=gt_labels,\\n groundtruth_is_difficult_list=groundtruth_is_difficult_list,\\n groundtruth_is_group_of_list=groundtruth_is_group_of_list\\n )\\n )\\n\\n for i, tp_fp_labels_cat in enumerate(tp_fp_labels):\\n assert sum(tp_fp_labels_cat) <= sum(gt_labels == i) # true positives < gt of that category\\n cat = i + 1 # categories start at 1\\n detection_tp_fp[cat].append(tp_fp_labels_cat)\\n detection_scores[cat].append(scores[i])\\n num_total_gt[cat] += sum(gt_labels == i) # gt_labels start at 0\\n\\n all_scores = []\\n all_tp_fp = []\\n\\n print('Computing precision recall for each category...')\\n per_cat_metrics = {}\\n for i in range(num_gt_classes):\\n cat = i + 1\\n scores_cat = np.concatenate(detection_scores[cat])\\n tp_fp_cat = np.concatenate(detection_tp_fp[cat]).astype(np.bool)\\n all_scores.append(scores_cat)\\n all_tp_fp.append(tp_fp_cat)\\n\\n precision, recall = metrics.compute_precision_recall(\\n scores_cat, tp_fp_cat, num_total_gt[cat]\\n )\\n average_precision = metrics.compute_average_precision(precision, recall)\\n\\n per_cat_metrics[cat] = {\\n 'category': cat,\\n 'precision': precision,\\n 'recall': recall,\\n 'average_precision': average_precision,\\n 'scores': scores_cat,\\n 'tp_fp': tp_fp_cat,\\n 'num_gt': num_total_gt[cat]\\n }\\n print('Number of ground truth in category {} is {}'.format(cat, num_total_gt[cat]))\\n\\n # compute one-class precision/recall/average precision (if every box is just of an object class)\\n all_scores = np.concatenate(all_scores)\\n all_tp_fp = np.concatenate(all_tp_fp)\\n overall_gt_count = sum(num_total_gt.values())\\n\\n one_class_prec, one_class_recall = metrics.compute_precision_recall(\\n all_scores, all_tp_fp, overall_gt_count\\n )\\n one_class_average_precision = metrics.compute_average_precision(one_class_prec, one_class_recall)\\n\\n per_cat_metrics['one_class'] = {\\n 'category': 'one_class',\\n 'precision': one_class_prec,\\n 'recall': one_class_recall,\\n 'average_precision': one_class_average_precision,\\n 'scores': all_scores,\\n 'tp_fp': all_tp_fp,\\n 'num_gt': overall_gt_count\\n }\\n\\n return per_cat_metrics\",\n \"def classify_image(img_pil):\\n results = tpu.ClassifyWithImage(img_pil, top_k=1)\\n if len(results) == 0:\\n return None, None\\n i, score = results[0]\\n label = labels[i]\\n # print(label + \\\": \\\" + str(score))\\n return label, score\",\n \"def vis_detections(im, class_name, dets, thresh=0.5):\\n global CHECK\\n global CLASS_NAME\\n global INDS\\n global RES\\n inds = np.where(dets[:, -1] >= thresh)[0]\\n if len(inds) == 0:\\n return\\n bbox = dets[inds[0], :4]\\n score = dets[inds[0], -1]\\n if len(inds) > 1:\\n score = -1\\n for i in inds:\\n temp = dets[i, -1]\\n if (temp > score):\\n score = temp\\n bbox = dets[i, :4]\\n if score <= MAX_SCORE[0]:\\n return\\n else:\\n CHECK = 1\\n MAX_SCORE[0] = score\\n CLASS_NAME = class_name\\n # im = im[:, :, (2, 1, 0)]\\n # fig, ax = plt.subplots()\\n # ax.imshow(im, aspect='equal')\\n # ax.add_patch(\\n # plt.Rectangle((bbox[0], bbox[1]),\\n # bbox[2] - bbox[0],\\n # bbox[3] - bbox[1], fill=False,\\n # edgecolor='red', linewidth=3.5)\\n # )\\n # ax.text(bbox[0], bbox[1] - 2,\\n # '{:s} {:.3f}'.format(class_name, score),\\n # bbox=dict(facecolor='blue', alpha=0.5),\\n # fontsize=10, color='white')\\n # ax.set_title(('{} detections with '\\n # 'p({} | box) >= {:.1f}').format(class_name, class_name,\\n # thresh),\\n # fontsize=10)\\n # plt.axis('off')\\n # plt.tight_layout()\\n # plt.draw()\",\n \"def vis_detections(im, class_name, dets, thresh=0.8):\\n for i in range(np.minimum(10, dets.shape[0])):\\n bbox = tuple(int(np.round(x)) for x in dets[i, :4])\\n score = dets[i, -1]\\n if score > thresh:\\n cv2.rectangle(im, bbox[0:2], bbox[2:4], (0, 204, 0), 2)\\n cv2.putText(im, '%s: %.3f' % (class_name, score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_PLAIN,\\n 1.0, (0, 0, 255), thickness=1)\\n return im\",\n \"def draw_detections(self, img, yolo_results):\\n\\n _, height, _ = img.shape\\n for yolo_result in yolo_results:\\n class_index = yolo_result.class_index\\n obj_name = yolo_result.obj_name\\n x = yolo_result.x_min\\n y = yolo_result.y_min\\n w = yolo_result.width\\n h = yolo_result.height\\n\\n offset = class_index * 123457 % self.meta.classes\\n\\n red = self._get_color(2, offset, self.meta.classes)\\n green = self._get_color(1, offset, self.meta.classes)\\n blue = self._get_color(0, offset, self.meta.classes)\\n box_width = int(height * 0.006)\\n cv2.rectangle(img, (int(x), int(y)), (int(x+w)+1, int(y+h)+1), (red, green, blue), box_width)\\n cv2.putText(img, obj_name, (int(x) -1, int(y) -1), cv2.FONT_HERSHEY_PLAIN, 2, (red, green, blue), 2)\\n\\n return img\",\n \"def classifier():\\n\\tprint(\\\"Classifying\\\")\\n\\t#initialize important variables\\n\\tminConfidence = 0.5\\n\\tthresholdValue = 0.3\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tfile = request.files#['image']\\n\\tfile.save(\\\"./classifier_image.jpg\\\")\\n\\tframe = cv2.imread(\\\"./classifier_image.jpg\\\")\\n\\t\\\"\\\"\\\"\\n\\tfile = request.json\\n\\tframe = np.array(file[\\\"Frame\\\"], dtype = \\\"uint8\\\") \\n\\n\\t#file = request.files['image']\\n\\t#file.save(\\\"./classifier_image.jpg\\\")\\n\\t#frame = cv2.imread(\\\"./classifier_image.jpg\\\")\\n\\t#file = request.json\\n\\t#frame = np.array(file[\\\"contour\\\"], dtype=\\\"uint8\\\")\\n\\t\\n\\t#Get Image dimensions\\n\\timage = cv2.copyMakeBorder(frame, 30, 30, 30, 30, cv2.BORDER_CONSTANT, value=255)\\n\\t(H, W) = image.shape[:2]\\n\\t\\n\\t#Get the output layers parameters\\n\\tln = net.getLayerNames()\\n\\tln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]\\n\\t\\n\\t#Create a blob to do a forward pass\\n\\tblob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False)\\n\\tnet.setInput(blob)\\n\\t#print(H, W)\\n\\tlayerOutputs = net.forward(ln)\\n\\tprint(type(net))\\n\\tboxes = []\\n\\tconfidences = []\\n\\tclassIDs = []\\n\\tfor output in layerOutputs:\\n\\t\\tprint(\\\"detecting\\\")\\n\\t\\t#loop over each detection\\n\\t\\tfor detection in output:\\n\\t\\t\\t# extract the class ID and confidence (i.e., probability) of\\n\\t\\t\\t# the current object detection\\n\\t\\t\\tscores = detection[5:]\\n\\t\\t\\tclassID = np.argmax(scores)\\n\\t\\t\\tconfidence = scores[classID]\\n\\n\\t\\t\\t# filter out weak predictions by ensuring the detected\\n\\t\\t\\t# probability is greater than the minimum probability\\n\\t\\t\\tif confidence > minConfidence:\\n\\t\\t\\t\\t# scale the bounding box coordinates back relative to the\\n\\t\\t\\t\\t# size of the image, keeping in mind that YOLO actually\\n\\t\\t\\t\\t# returns the center (x, y)-coordinates of the bounding\\n\\t\\t\\t\\t# box followed by the boxes' width and height\\n\\t\\t\\t\\tbox = detection[0:4] * np.array([W, H, W, H])\\n\\t\\t\\t\\t(centerX, centerY, width, height) = box.astype(\\\"int\\\")\\n\\n\\t\\t\\t\\t# use the center (x, y)-coordinates to derive the top and\\n\\t\\t\\t\\t# and left corner of the bounding box\\n\\t\\t\\t\\tx = int(centerX - (width / 2))\\n\\t\\t\\t\\ty = int(centerY - (height / 2))\\n\\n\\t\\t\\t\\t# update our list of bounding box coordinates, confidences,\\n\\t\\t\\t\\t# and class IDs\\n\\t\\t\\t\\tboxes.append([x, y, int(width), int(height)])\\n\\t\\t\\t\\tconfidences.append(float(confidence))\\n\\t\\t\\t\\tclassIDs.append(classID)\\n\\n\\t# apply non-maxima suppression to suppress weak, overlapping bounding\\n\\t# boxes\\n\\tidxs = cv2.dnn.NMSBoxes(boxes, confidences, minConfidence, thresholdValue)\\n\\n\\t# ensure at least one detection exists\\n\\tif len(idxs) > 0:\\n\\t\\toutput = json.load(open(outputFile))\\n\\t\\t# loop over the indexes we are keeping\\n\\t\\tfor i in idxs.flatten():\\n\\t\\t\\t# extract the bounding box coordinates\\n\\t\\t\\t(x, y) = (boxes[i][0], boxes[i][1])\\n\\t\\t\\t(w, h) = (boxes[i][2], boxes[i][3])\\n\\n\\t\\t\\tprint(LABELS[classIDs[i]], output[LABELS[classIDs[i]]]+1, confidences[i])\\n\\t\\t\\toutput[LABELS[classIDs[i]]]+=1\\n\\t\\t\\n\\t\\tjson.dump(output, open(outputFile, \\\"w\\\"))\\n\\t\\treturn LABELS[classIDs[i]]\\n\\telse:\\n\\t\\treturn Response(status=200)\",\n \"def im_detect(net, target_data,im_data, im_info, features_given=True):\\n\\n cls_prob, rois = net(target_data, im_data, im_info,\\n features_given=features_given)\\n scores = cls_prob.data.cpu().numpy()[0,:,:]\\n zs = np.zeros((scores.size, 1))\\n scores = np.concatenate((zs,scores),1)\\n boxes = rois.data.cpu().numpy()[0,:, :]\\n\\n return scores, boxes\",\n \"def classProbs(observation, tree, classes):\\n res = classify(observation, tree) #res = results\\n total = sum(res.values())\\n probs = []\\n for c in classes:\\n if c in res.keys():\\n probs.append(float(res[c])/total)\\n else:\\n probs.append(0)\\n return probs\",\n \"def postprocess(self, prediction_dict, true_image_shapes, **params):\\n object_center_prob = tf.nn.sigmoid(prediction_dict[OBJECT_CENTER][-1])\\n\\n if true_image_shapes is None:\\n # If true_image_shapes is not provided, we assume the whole image is valid\\n # and infer the true_image_shapes from the object_center_prob shape.\\n batch_size, strided_height, strided_width, _ = _get_shape(\\n object_center_prob, 4)\\n true_image_shapes = tf.stack(\\n [strided_height * self._stride, strided_width * self._stride,\\n tf.constant(len(self._feature_extractor._channel_means))]) # pylint: disable=protected-access\\n true_image_shapes = tf.stack([true_image_shapes] * batch_size, axis=0)\\n else:\\n # Mask object centers by true_image_shape. [batch, h, w, 1]\\n object_center_mask = mask_from_true_image_shape(\\n _get_shape(object_center_prob, 4), true_image_shapes)\\n object_center_prob *= object_center_mask\\n\\n # Get x, y and channel indices corresponding to the top indices in the class\\n # center predictions.\\n detection_scores, y_indices, x_indices, channel_indices = (\\n top_k_feature_map_locations(\\n object_center_prob,\\n max_pool_kernel_size=self._center_params.peak_max_pool_kernel_size,\\n k=self._center_params.max_box_predictions))\\n multiclass_scores = tf.gather_nd(\\n object_center_prob, tf.stack([y_indices, x_indices], -1), batch_dims=1)\\n num_detections = tf.reduce_sum(\\n tf.cast(detection_scores > 0, tf.int32), axis=1)\\n postprocess_dict = {\\n fields.DetectionResultFields.detection_scores: detection_scores,\\n fields.DetectionResultFields.detection_multiclass_scores:\\n multiclass_scores,\\n fields.DetectionResultFields.detection_classes: channel_indices,\\n fields.DetectionResultFields.num_detections: num_detections,\\n }\\n\\n if self._output_prediction_dict:\\n postprocess_dict.update(prediction_dict)\\n postprocess_dict['true_image_shapes'] = true_image_shapes\\n\\n boxes_strided = None\\n if self._od_params:\\n boxes_strided = (\\n prediction_tensors_to_boxes(y_indices, x_indices,\\n prediction_dict[BOX_SCALE][-1],\\n prediction_dict[BOX_OFFSET][-1]))\\n\\n boxes = convert_strided_predictions_to_normalized_boxes(\\n boxes_strided, self._stride, true_image_shapes)\\n\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_boxes: boxes,\\n 'detection_boxes_strided': boxes_strided,\\n })\\n\\n if self._kp_params_dict:\\n # If the model is trained to predict only one class of object and its\\n # keypoint, we fall back to a simpler postprocessing function which uses\\n # the ops that are supported by tf.lite on GPU.\\n clip_keypoints = self._should_clip_keypoints()\\n if len(self._kp_params_dict) == 1 and self._num_classes == 1:\\n task_name, kp_params = next(iter(self._kp_params_dict.items()))\\n keypoint_depths = None\\n if kp_params.argmax_postprocessing:\\n keypoints, keypoint_scores = (\\n prediction_to_keypoints_argmax(\\n prediction_dict,\\n object_y_indices=y_indices,\\n object_x_indices=x_indices,\\n boxes=boxes_strided,\\n task_name=task_name,\\n kp_params=kp_params))\\n else:\\n (keypoints, keypoint_scores,\\n keypoint_depths) = self._postprocess_keypoints_single_class(\\n prediction_dict, channel_indices, y_indices, x_indices,\\n boxes_strided, num_detections)\\n keypoints, keypoint_scores = (\\n convert_strided_predictions_to_normalized_keypoints(\\n keypoints, keypoint_scores, self._stride, true_image_shapes,\\n clip_out_of_frame_keypoints=clip_keypoints))\\n if keypoint_depths is not None:\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_keypoint_depths:\\n keypoint_depths\\n })\\n else:\\n # Multi-class keypoint estimation task does not support depth\\n # estimation.\\n assert all([\\n not kp_dict.predict_depth\\n for kp_dict in self._kp_params_dict.values()\\n ])\\n keypoints, keypoint_scores = self._postprocess_keypoints_multi_class(\\n prediction_dict, channel_indices, y_indices, x_indices,\\n boxes_strided, num_detections)\\n keypoints, keypoint_scores = (\\n convert_strided_predictions_to_normalized_keypoints(\\n keypoints, keypoint_scores, self._stride, true_image_shapes,\\n clip_out_of_frame_keypoints=clip_keypoints))\\n\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_keypoints: keypoints,\\n fields.DetectionResultFields.detection_keypoint_scores:\\n keypoint_scores\\n })\\n if self._od_params is None:\\n # Still output the box prediction by enclosing the keypoints for\\n # evaluation purpose.\\n boxes = keypoint_ops.keypoints_to_enclosing_bounding_boxes(\\n keypoints, keypoints_axis=2)\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_boxes: boxes,\\n })\\n\\n if self._mask_params:\\n masks = tf.nn.sigmoid(prediction_dict[SEGMENTATION_HEATMAP][-1])\\n densepose_part_heatmap, densepose_surface_coords = None, None\\n densepose_class_index = 0\\n if self._densepose_params:\\n densepose_part_heatmap = prediction_dict[DENSEPOSE_HEATMAP][-1]\\n densepose_surface_coords = prediction_dict[DENSEPOSE_REGRESSION][-1]\\n densepose_class_index = self._densepose_params.class_id\\n instance_masks, surface_coords = (\\n convert_strided_predictions_to_instance_masks(\\n boxes, channel_indices, masks, true_image_shapes,\\n densepose_part_heatmap, densepose_surface_coords,\\n stride=self._stride, mask_height=self._mask_params.mask_height,\\n mask_width=self._mask_params.mask_width,\\n score_threshold=self._mask_params.score_threshold,\\n densepose_class_index=densepose_class_index))\\n postprocess_dict[\\n fields.DetectionResultFields.detection_masks] = instance_masks\\n if self._densepose_params:\\n postprocess_dict[\\n fields.DetectionResultFields.detection_surface_coords] = (\\n surface_coords)\\n\\n if self._track_params:\\n embeddings = self._postprocess_embeddings(prediction_dict,\\n y_indices, x_indices)\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_embeddings: embeddings\\n })\\n\\n if self._temporal_offset_params:\\n offsets = prediction_tensors_to_temporal_offsets(\\n y_indices, x_indices,\\n prediction_dict[TEMPORAL_OFFSET][-1])\\n postprocess_dict[fields.DetectionResultFields.detection_offsets] = offsets\\n\\n if self._non_max_suppression_fn:\\n boxes = tf.expand_dims(\\n postprocess_dict.pop(fields.DetectionResultFields.detection_boxes),\\n axis=-2)\\n multiclass_scores = postprocess_dict[\\n fields.DetectionResultFields.detection_multiclass_scores]\\n num_classes = tf.shape(multiclass_scores)[2]\\n class_mask = tf.cast(\\n tf.one_hot(\\n postprocess_dict[fields.DetectionResultFields.detection_classes],\\n depth=num_classes), tf.bool)\\n # Surpress the scores of those unselected classes to be zeros. Otherwise,\\n # the downstream NMS ops might be confused and introduce issues.\\n multiclass_scores = tf.where(\\n class_mask, multiclass_scores, tf.zeros_like(multiclass_scores))\\n num_valid_boxes = postprocess_dict.pop(\\n fields.DetectionResultFields.num_detections)\\n # Remove scores and classes as NMS will compute these form multiclass\\n # scores.\\n postprocess_dict.pop(fields.DetectionResultFields.detection_scores)\\n postprocess_dict.pop(fields.DetectionResultFields.detection_classes)\\n (nmsed_boxes, nmsed_scores, nmsed_classes, _, nmsed_additional_fields,\\n num_detections) = self._non_max_suppression_fn(\\n boxes,\\n multiclass_scores,\\n additional_fields=postprocess_dict,\\n num_valid_boxes=num_valid_boxes)\\n postprocess_dict = nmsed_additional_fields\\n postprocess_dict[\\n fields.DetectionResultFields.detection_boxes] = nmsed_boxes\\n postprocess_dict[\\n fields.DetectionResultFields.detection_scores] = nmsed_scores\\n postprocess_dict[\\n fields.DetectionResultFields.detection_classes] = nmsed_classes\\n postprocess_dict[\\n fields.DetectionResultFields.num_detections] = num_detections\\n postprocess_dict.update(nmsed_additional_fields)\\n\\n # Perform the rescoring once the NMS is applied to make sure the rescored\\n # scores won't be washed out by the NMS function.\\n if self._kp_params_dict:\\n channel_indices = postprocess_dict[\\n fields.DetectionResultFields.detection_classes]\\n detection_scores = postprocess_dict[\\n fields.DetectionResultFields.detection_scores]\\n keypoint_scores = postprocess_dict[\\n fields.DetectionResultFields.detection_keypoint_scores]\\n # Update instance scores based on keypoints.\\n scores = self._rescore_instances(\\n channel_indices, detection_scores, keypoint_scores)\\n postprocess_dict.update({\\n fields.DetectionResultFields.detection_scores: scores,\\n })\\n return postprocess_dict\",\n \"def inference(self, img, probe_roi=None, threshold=0.75):\\n device = self.cls_score.weight.device\\n processed_img, scale = img_preprocessing(img)\\n # [C, H, W] -> [N, C, H, W]\\n processed_img = torch.from_numpy(processed_img).unsqueeze(0).to(device)\\n # img_info: (height, width, scale)\\n img_info = torch.Tensor([processed_img.shape[2], processed_img.shape[3], scale]).to(device)\\n if probe_roi is not None:\\n probe_roi = torch.from_numpy(probe_roi).float().view(1, 4)\\n probe_roi *= scale\\n # Add an extra 0, which means the probe_roi is from the first image in the batch\\n probe_roi = torch.cat((torch.zeros(1, 1), probe_roi.float()), dim=1).to(device)\\n\\n with torch.no_grad():\\n proposals, probs, proposal_deltas, features, _, _, _, _, _ = self.forward(\\n processed_img, img_info, None, probe_roi\\n )\\n\\n if probe_roi is not None:\\n return features\\n\\n # Unscale proposals back to raw image space\\n proposals = proposals[:, 1:5] / scale\\n # Unnormalize proposal deltas\\n num_classes = proposal_deltas.shape[1] // 4\\n stds = torch.Tensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).repeat(num_classes).to(device)\\n means = torch.Tensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).repeat(num_classes).to(device)\\n proposal_deltas = proposal_deltas * stds + means\\n # Apply proposal regression deltas\\n boxes = bbox_transform_inv(proposals, proposal_deltas)\\n boxes = clip_boxes(boxes, img.shape)\\n\\n # Remove those boxes with scores below the threshold\\n j = 1 # Only consider foreground class\\n keep = torch.nonzero(probs[:, j] > threshold, as_tuple=False)[:, 0]\\n boxes = boxes[keep, j * 4 : (j + 1) * 4]\\n probs = probs[keep, j]\\n features = features[keep]\\n\\n # Remove redundant boxes with NMS\\n detections = torch.cat((boxes, probs.unsqueeze(1)), dim=1)\\n keep = nms(boxes, probs, cfg.TEST.NMS)\\n detections = detections[keep]\\n features = features[keep]\\n\\n return detections, features\",\n \"def classify_image(image, model, image_box=None):\\n images_list = []\\n image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT), box=image_box)\\n # box argument clips image to (x1, y1, x2, y2)\\n image = np.array(image)\\n images_list.append(image)\\n \\n return [np.argmax(model.predict(np.array(images_list)))]\",\n \"def detect_from_image(self, imageMatrix):\\n image = imageMatrix #TODO\\n self.imageHeight, self.imageWidth, _ = imageMatrix.shape\\n # Resize the image as required by network\\n # Make image shape 1x448x448x3\\n # Normalize the image values between -1 and 1\\n imageMatrix = np.expand_dims(\\n np.asarray(\\n cv2.cvtColor(\\n cv2.resize(\\n imageMatrix, (448, 448)\\n ), cv2.COLOR_BGR2RGB\\n ), dtype='float32')/255.*2. - 1., axis=0)\\n # Run image through network and get its output\\n netOutput = self.sess.run(self.fc3, feed_dict={self.x: imageMatrix})\\n # Figure out the object classes and bounding boxes from the\\n # network output\\n self.result = self.interpret_output(netOutput)\\n # Make an annotated image with the classes and bounding boxes\\n return self.annotate_image(image, self.result)\",\n \"def detect_objects(self, predicted_locs, predicted_scores, min_score, max_overlap, top_k):\\n batch_size = predicted_locs.size(0)\\n n_priors = self.priors_cxcy.size(0)\\n predicted_scores = F.softmax(predicted_scores, dim=2) # (N, 8732, n_classes)\\n\\n # Lists to store final predicted boxes, labels, and scores for all images\\n all_images_boxes = list()\\n all_images_labels = list()\\n all_images_scores = list()\\n\\n assert n_priors == predicted_locs.size(1) == predicted_scores.size(1)\\n\\n for i in range(batch_size):\\n # Decode object coordinates from the form we regressed predicted boxes to\\n decoded_locs = cxcy_to_xy(\\n gcxgcy_to_cxcy(predicted_locs[i], self.priors_cxcy)) # (8732, 4), these are fractional pt. coordinates\\n\\n # Lists to store boxes and scores for this image\\n image_boxes = list()\\n image_labels = list()\\n image_scores = list()\\n\\n max_scores, best_label = predicted_scores[i].max(dim=1) # (8732)\\n\\n # Check for each class\\n for c in range(1, self.n_classes):\\n # Keep only predicted boxes and scores where scores for this class are above the minimum score\\n class_scores = predicted_scores[i][:, c] # (8732)\\n score_above_min_score = class_scores > min_score # torch.uint8 (byte) tensor, for indexing\\n n_above_min_score = score_above_min_score.sum().item()\\n if n_above_min_score == 0:\\n continue\\n class_scores = class_scores[score_above_min_score] # (n_qualified), n_min_score <= 8732\\n class_decoded_locs = decoded_locs[score_above_min_score] # (n_qualified, 4)\\n\\n # Sort predicted boxes and scores by scores\\n class_scores, sort_ind = class_scores.sort(dim=0, descending=True) # (n_qualified), (n_min_score)\\n class_decoded_locs = class_decoded_locs[sort_ind] # (n_min_score, 4)\\n\\n # Find the overlap between predicted boxes\\n overlap = find_jaccard_overlap(class_decoded_locs, class_decoded_locs) # (n_qualified, n_min_score)\\n\\n #-- Non-Maximum Suppression (NMS)\\n # A torch.uint8 (byte) tensor to keep track of which predicted boxes to suppress\\n # 1 implies suppress, 0 implies don't suppress\\n suppress = torch.zeros((n_above_min_score), dtype=torch.uint8).to(self.device) # (n_qualified)\\n\\n # Consider each box in order of decreasing scores\\n for box in range(class_decoded_locs.size(0)):\\n # If this box is already marked for suppression\\n if suppress[box] == 1:\\n continue\\n\\n # Suppress boxes whose overlaps (with this box) are greater than maximum overlap\\n # Find such boxes and update suppress indices\\n suppress = suppress.bool() | (overlap[box] > max_overlap).bool()\\n # The max operation retains previously suppressed boxes, like an 'OR' operation\\n\\n # Don't suppress this box, even though it has an overlap of 1 with itself\\n suppress[box] = 0\\n\\n # Store only unsuppressed boxes for this class\\n image_boxes.append(class_decoded_locs[~suppress])\\n image_labels.append(\\n torch.LongTensor(\\n (~suppress).sum().item() * [c]).to(self.device)\\n )\\n image_scores.append(class_scores[~suppress])\\n\\n # image_boxes.append(class_decoded_locs[1 - suppress])\\n # image_labels.append(torch.LongTensor((1 - suppress).sum().item() * [c]).to(self.device))\\n # image_scores.append(class_scores[1 - suppress])\\n\\n # If no object in any class is found, store a placeholder for 'background'\\n if len(image_boxes) == 0:\\n image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(self.device))\\n image_labels.append(torch.LongTensor([0]).to(self.device))\\n image_scores.append(torch.FloatTensor([0.]).to(self.device))\\n\\n # Concatenate into single tensors\\n image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4)\\n image_labels = torch.cat(image_labels, dim=0) # (n_objects)\\n image_scores = torch.cat(image_scores, dim=0) # (n_objects)\\n n_objects = image_scores.size(0)\\n\\n # Keep only the top k objects\\n if n_objects > top_k:\\n image_scores, sort_ind = image_scores.sort(dim=0, descending=True)\\n image_scores = image_scores[:top_k] # (top_k)\\n image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4)\\n image_labels = image_labels[sort_ind][:top_k] # (top_k)\\n\\n # Append to lists that store predicted boxes and scores for all images\\n all_images_boxes.append(image_boxes)\\n all_images_labels.append(image_labels)\\n all_images_scores.append(image_scores)\\n\\n return all_images_boxes, all_images_labels, all_images_scores # lists of length batch_size\",\n \"def detect_fn(image):\\n\\n image, shapes = model.preprocess(image)\\n prediction_dict = model.predict(image, shapes)\\n detections = model.postprocess(prediction_dict, shapes)\\n\\n return detections, prediction_dict, tf.reshape(shapes, [-1])\",\n \"def im_detect(net, im, boxes):\\n blobs, unused_im_scale_factors = _get_blobs(im, boxes)\\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\\n # (some distinct image ROIs get mapped to the same feature ROI).\\n # Here, we identify duplicate feature ROIs, so we only compute features\\n # on the unique subset.\\n for i in range(len(blobs['data'])):\\n if cfg.DEDUP_BOXES > 0:\\n v = np.array([1, 1e3, 1e6, 1e9, 1e12])\\n hashes = np.round(blobs['rois'][i] * cfg.DEDUP_BOXES).dot(v)\\n _, index, inv_index = np.unique(hashes, return_index=True,\\n return_inverse=True)\\n blobs['rois'][i] = blobs['rois'][i][index, :]\\n boxes_tmp = boxes[index, :].copy()\\n else:\\n boxes_tmp = boxes.copy()\\n t_data = blobs['data'][i].astype(np.float32, copy=False)\\n #t_data = t_data.reshape((1, t_data.shape[0], t_data.shape[1], t_data.shape[2], t_data.shape[3]))\\n data_height, data_width = t_data.shape[1], t_data.shape[2]\\n im_data = torch.FloatTensor(t_data).cuda()\\n im_data = im_data.permute(0, 3, 1, 2).contiguous() #.view(3, data_height, data_width)\\n LIM = 2000 # split ROIs due to memory issue\\n if cfg.TEST.USE_FLIPPED :\\n blobs['data'][i] = blobs['data'][i][:, :, ::-1, :]\\n width = blobs['data'][i].shape[2]\\n t_data = blobs['data'][i].astype(np.float32, copy=False)\\n data_height, data_width = t_data.shape[1], t_data.shape[2]\\n #im_data = torch.FloatTensor(t_data).cuda()\\n im_data_flip = torch.from_numpy(t_data.copy()).cuda()\\n im_data_flip = im_data_flip.permute(0, 3, 1, 2).contiguous()#.view(3, data_height, data_width)\\n #im_data = im_data[...,::-1]\\n for j in range (int(np.ceil(blobs['rois'][i].shape[0] / LIM))) :\\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\\n im_rois = torch.FloatTensor(t_rois).cuda()\\n ic_prob, ic_prob1, ic_prob2 = net(im_data, im_rois)\\n scores_tmp = ic_prob + ic_prob1 + ic_prob2\\n pred_boxes_small = np.tile(boxes_tmp[j*LIM : (j+1)*LIM], (1, scores_tmp.shape[2]))\\n\\n if cfg.TEST.USE_FLIPPED:\\n #pdb.set_trace()\\n oldx1 = blobs['rois'][i][j*LIM:(j+1)*LIM, 1].copy()\\n oldx2 = blobs['rois'][i][j*LIM:(j+1)*LIM, 3].copy()\\n blobs['rois'][i][j*LIM:(j+1)*LIM, 1] = width - oldx2 - 1\\n blobs['rois'][i][j*LIM:(j+1)*LIM, 3] = width - oldx1 - 1\\n assert (blobs['rois'][i][j*LIM:(j+1)*LIM, 3] >= blobs['rois'][i][j*LIM:(j+1)*LIM, 1]).all()\\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\\n im_rois = torch.FloatTensor(t_rois).cuda()\\n ic_prob, ic_prob1, ic_prob2 = net(im_data_flip, im_rois)\\n scores_tmp += ic_prob + ic_prob1 + ic_prob2\\n del im_rois\\n\\n if j is 0 :\\n scores_tmp_real = scores_tmp\\n pred_boxes = pred_boxes_small\\n else :\\n scores_tmp_real = torch.cat((scores_tmp_real, scores_tmp), dim=1)\\n pred_boxes = np.vstack((pred_boxes, pred_boxes_small))\\n\\n\\n if cfg.DEDUP_BOXES > 0:\\n # Map scores and predictions back to the original set of boxes\\n scores_tmp = scores_tmp_real[:,inv_index, :]\\n pred_boxes = pred_boxes[inv_index, :]\\n \\n if i == 0: \\n scores = np.copy(scores_tmp.data).squeeze()\\n if len(scores.shape) == 1 :\\n scores = scores[np.newaxis, :]\\n else:\\n scores += scores_tmp[0].data\\n\\n scores /= len(blobs['data']) * (1. + cfg.TEST.USE_FLIPPED)\\n return scores[:,1:], pred_boxes[:, 4:]\",\n \"def count_classes(labels):\\n class_dict = {}\\n for image in labels:\\n for row in image:\\n for label in row:\\n if label not in class_dict:\\n class_dict[label] = 1\\n else:\\n class_dict[label] += 1\\n return class_dict\",\n \"def detect_fn(image):\\r\\n\\r\\n image, shapes = model.preprocess(image)\\r\\n prediction_dict = model.predict(image, shapes)\\r\\n detections = model.postprocess(prediction_dict, shapes)\\r\\n\\r\\n return detections, prediction_dict, tf.reshape(shapes, [-1])\",\n \"def describe(image):\\n needle = cv2.imread(image, 0)\\n orb = cv2.ORB()\\n keypoints, description = orb.detectAndCompute(needle, None)\\n print(keypoints)\\n print(description)\\n return keypoints, description\",\n \"def detect(self, image):\\n\\n\\t\\t(rect, weights) = self.hog.detectMultiScale(image, winStride=(4, 4), padding=(16, 16), scale=1.09)\\n\\n\\t\\t# non-maxima suppression applied to the boxes\\n\\t\\trect = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rect])\\n\\t\\tboxes = non_max_suppression(rect, probs=None, overlapThresh=0.3)\\n\\n\\t\\t# draw of the rectangles around people\\n\\t\\thuman_boxes = []\\n\\t\\tthickness = 1\\n\\t\\tfor i in range(len(boxes)):\\n\\t\\t\\tx = boxes[i][0]\\n\\t\\t\\ty = boxes[i][1]\\n\\t\\t\\tw = boxes[i][2]\\n\\t\\t\\th = boxes[i][3]\\n\\t\\t\\tp_w, p_h = int(0.1*w), int(0.025*h)\\n\\t\\t\\t#cv2.rectangle(image, (x + p_w, y + p_h), (x + w - p_w, y + h - p_h), (0, 255, 0), thickness)\\n\\n\\t\\t\\thuman_boxes.append([(x + p_w, y + p_h), (x + w - p_w, y + h - p_h)])\\n\\n\\t\\t# reformat and rearrange the boxes for convenience\\n\\t\\treturn human_boxes\",\n \"def _load_pascal_annotation(self, index):\\n image = index\\n im_path = self.image_path_from_index(image)\\n im = cv2.imread(im_path)\\n width = im.shape[1]\\n height = im.shape[0]\\n num_objs = 0\\n for ix, obj in enumerate(image.objects):\\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\\n continue \\n assert(image.objects[ix].width > 0)\\n assert(image.objects[ix].height > 0)\\n\\n num_objs += 1\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.float32)\\n\\n partial_entity_class = np.zeros((num_objs, 96), dtype=np.int32)\\n partial_relation_class = np.zeros((num_objs, num_objs, 43), dtype=np.int32)\\n gt_classes = np.zeros((0, num_objs, 1), dtype=np.int32)\\n overlaps = np.zeros((0, num_objs, self.num_classes), dtype=np.int64)\\n # \\\"Seg\\\" area for pascal is just the box area\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n queries = np.zeros((0, 235), dtype=np.float32)\\n # Load object bounding boxes into a data frame.\\n index = 0\\n \\n for ix, obj in enumerate(image.objects):\\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\\n continue\\n # Make pixel indexes 0-based\\n x1_offset = 0.0#image.objects[ix].width * (-0.1)\\n x2_offset = 0.0#image.objects[ix].width * 0.1\\n y1_offset = 0.0#image.objects[ix].height * (-0.1)\\n y2_offset = 0.0#image.objects[ix].height * 0.1\\n boxes[index][0] = max((image.objects[ix].x + x1_offset), 0.0)\\n boxes[index][1] = max((image.objects[ix].y + y1_offset), 0.0)\\n boxes[index][2] = min((image.objects[ix].x + x2_offset + image.objects[ix].width), width - 1)\\n boxes[index][3] = min((image.objects[ix].y + y2_offset + image.objects[ix].height), height - 1)\\n seg_areas[index] = (boxes[index][2] - boxes[index][0] + 1.0) * (boxes[index][3] - boxes[index][1] + 1.0)\\n index += 1\\n assert (boxes[:, 2] > boxes[:, 0]).all()\\n assert (boxes[:, 3]\\t > boxes[:, 1]).all() \\n #load gt classes\\n \\n i_index = 0\\n for i in range(image.objects_labels.shape[0]):\\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\\n continue\\n partial_entity_class[i_index] = image.objects_labels[i]\\n \\n j_index = 0\\n for j in range(image.objects_labels.shape[0]):\\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\\n continue\\n partial_relation_class[i_index, j_index] = image.predicates_labels[i, j]\\n j_index += 1\\n i_index += 1\\n seen = []\\n for query_index in range(image.queries_gt.shape[0]):\\n query_gt_classes = np.zeros((1, num_objs, 1), dtype=np.int32)\\n query_overlaps = np.zeros((1, num_objs, self.num_classes), dtype=np.int64)\\n query_overlaps[0, :, 3] = 1\\n query_gt_classes[0, :, 0] = 3\\n if image.one_hot_relations_gt[query_index][-1] == 1:\\n # print \\\"negative triplet\\\"\\n continue\\n\\n sub = image.one_hot_relations_gt[query_index][:96]\\n obj = image.one_hot_relations_gt[query_index][96:96 * 2]\\n rel = image.one_hot_relations_gt[query_index][96 * 2:]\\n key = str(np.argmax(sub)) + \\\"_\\\" + str(np.argmax(rel)) + \\\"_\\\" + str(np.argmax(obj))\\n if key in seen:\\n continue\\n seen.append(key)\\n\\n found = False\\n i_index = 0\\n for i in range(image.objects_labels.shape[0]):\\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\\n continue\\n if not np.array_equal(image.objects_labels[i], sub):\\n i_index += 1\\n continue\\n j_index = 0\\n for j in range(image.objects_labels.shape[0]):\\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\\n continue \\n\\n if not np.array_equal(image.objects_labels[j], obj):\\n j_index += 1\\n continue\\n if np.array_equal(rel, image.predicates_labels[i, j]):\\n query_gt_classes[0, i_index, 0] = 1\\n query_overlaps[0, i_index, 1] = 1\\n query_overlaps[0, i_index, 3] = 0\\n query_gt_classes[0, j_index, 0] = 2\\n query_overlaps[0, j_index, 2] = 1\\n query_overlaps[0, j_index, 3] = 0\\n \\n #partial_entity_class[i_index] = sub\\n #partial_entity_class[j_index] = obj\\n #partial_relation_class[i_index, j_index] = rel\\n \\n found = True\\n j_index += 1\\n i_index += 1\\n if not found:\\n continue\\n gt_classes = np.concatenate((gt_classes, query_gt_classes), axis=0)\\n overlaps = np.concatenate((overlaps, query_overlaps), axis=0)\\n queries = np.concatenate((queries, image.one_hot_relations_gt[query_index].reshape([1,-1])), axis=0)\\n\\n return {'boxes': boxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps': overlaps,\\n 'flipped': False,\\n 'seg_areas': seg_areas,\\n 'query' : queries,\\n 'partial_entity_class' : partial_entity_class,\\n 'partial_relation_class' : partial_relation_class,\\n 'orig_image': None}\",\n \"def classify(priors, likelihoods, testData, classes):\\r\\n results = []\\r\\n for document in testData:\\r\\n bestClass = None\\r\\n bestProb = None\\r\\n currentProb = 0.0\\r\\n for cls in classes:\\r\\n prior = priors[cls]\\r\\n currentProb = log(prior)\\r\\n lhoods = likelihoods[cls]\\r\\n for (word, count) in document:\\r\\n if word in lhoods:\\r\\n currentProb += log(lhoods[word])\\r\\n else:\\r\\n currentProb += log(lhoods[None])\\r\\n if currentProb > bestProb or bestClass == None:\\r\\n bestProb = currentProb\\r\\n bestClass = cls\\r\\n results.append(bestClass)\\r\\n return results\",\n \"def get_object_mask(self, image_id):\\n image_info = self.image_meta[image_id]\\n active_class_info = image_info['active_class_info']\\n object_cnt = len(active_class_info)\\n mask = np.zeros([image_info['height'], image_info['width'], object_cnt], dtype=np.uint8)\\n for i, (object_, _, dims) in enumerate(active_class_info):\\n mask[:, :, i:i + 1] = self.draw_object_shape(mask[:, :, i:i + 1].copy(), object_, 1, dims)\\n \\n # Handle occlusions, when two objects intersect, we should ensure that the intersection mask is\\n # given to only only object.\\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\\n # print(occlusion)\\n \\n for i in range(object_cnt - 2, -1, -1):\\n mask[:, :, i] = mask[:, :, i] * occlusion\\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\\n # Map class names to class IDs.\\n return mask.astype(np.bool)\",\n \"def im_detect(sess, net, im, boxes=None):\\n\\n blobs, im_scales = _get_blobs(im, boxes)\\n\\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\\n # (some distinct image ROIs get mapped to the same feature ROI).\\n # Here, we identify duplicate feature ROIs, so we only compute features\\n # on the unique subset.\\n\\n if cfg.TEST.HAS_RPN:\\n im_blob = blobs['data']\\n blobs['im_info'] = np.array(\\n [[im_blob.shape[1], im_blob.shape[2], im_scales[0]]],\\n dtype=np.float32)\\n # forward pass\\n if cfg.TEST.HAS_RPN:\\n feed_dict={net.data: blobs['data'], net.im_info: blobs['im_info'], net.keep_prob: 1.0}\\n else:\\n feed_dict={net.data: blobs['data'], net.rois: blobs['rois'], net.keep_prob: 1.0}\\n\\n run_options = None\\n run_metadata = None\\n if cfg.TEST.DEBUG_TIMELINE:\\n run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\\n run_metadata = tf.RunMetadata()\\n\\n cls_score, cls_prob, bbox_pred, rois = sess.run([net.get_output('cls_score'), net.get_output('cls_prob'), net.get_output('bbox_pred'),net.get_output('rois')],\\n feed_dict=feed_dict,\\n options=run_options,\\n run_metadata=run_metadata)\\n\\n if cfg.TEST.HAS_RPN:\\n assert len(im_scales) == 1, \\\"Only single-image batch implemented\\\"\\n boxes = rois[:, 1:5] / im_scales[0]\\n\\n\\n if cfg.TEST.SVM:\\n # use the raw scores before softmax under the assumption they\\n # were trained as linear SVMs\\n scores = cls_score\\n else:\\n # use softmax estimated probabilities\\n scores = cls_prob\\n\\n if cfg.TEST.BBOX_REG:\\n # Apply bounding-box regression deltas\\n box_deltas = bbox_pred\\n pred_boxes = bbox_transform_inv(boxes, box_deltas)\\n pred_boxes = _clip_boxes(pred_boxes, im.shape)\\n else:\\n # Simply repeat the boxes, once for each class\\n pred_boxes = np.tile(boxes, (1, scores.shape[1]))\\n\\n if cfg.TEST.DEBUG_TIMELINE:\\n trace = timeline.Timeline(step_stats=run_metadata.step_stats)\\n trace_file = open(str(long(time.time() * 1000)) + '-test-timeline.ctf.json', 'w')\\n trace_file.write(trace.generate_chrome_trace_format(show_memory=False))\\n trace_file.close()\\n\\n return scores, pred_boxes\",\n \"def preprocessing(image_data, max_height, max_width):\\n img = image_data[\\\"image\\\"]\\n img = resize_image(img, max_height, max_width)\\n gt_boxes = image_data[\\\"objects\\\"][\\\"bbox\\\"]\\n gt_labels = image_data[\\\"objects\\\"][\\\"label\\\"]\\n return img, gt_boxes, gt_labels\",\n \"def detect_primary_objects(gray, haar_file, params, num_primary_obj=1, max_iter=10, boost_flag=True, verbose=False):\\n haar_cascade = cv.CascadeClassifier(haar_file)\\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\\n num_detected = len(detected_objects)\\n num_detected_prev = num_detected\\n if verbose:\\n print(f\\\"Initial # of Objects Detected = {num_detected}\\\")\\n num_iter = 0\\n boost_factor = 1\\n while num_detected != num_primary_obj and num_iter != max_iter:\\n num_iter += 1\\n if verbose:\\n print(f\\\"Iteration # = {num_iter}\\\")\\n # Update minNeighbors value in copy of params dict\\n if num_iter == 1:\\n params_new = params.copy()\\n elif num_iter == max_iter:\\n print(f\\\"Maximum # of iterations ({max_iter}) reached!\\\")\\n # Change minNeighbors up/down depending on whether num detected is too high/low\\n # Steps up are twice as big as steps down, and boost_factor determines step size\\n if num_detected < num_primary_obj and params_new['minNeighbors'] > 4:\\n params_new['minNeighbors'] -= boost_factor\\n elif num_detected < num_primary_obj and params_new['minNeighbors'] > 1:\\n params_new['minNeighbors'] -= 1 \\n elif num_detected > num_primary_obj:\\n params_new['minNeighbors'] += 2 * boost_factor\\n else:\\n print(f\\\"Unable to detect {num_primary_obj} primary object(s) in input image\\\")\\n print(f\\\"Verify that either 1) num_detected is zero ({num_detected==0}) and minNeighbors is one ({params_new['minNeighbors']==1})\\\")\\n print(f\\\"OR 2) the maximum # of iterations has been reached ({num_iter==max_iter})\\\")\\n print(\\\"If either of these scenarios occurs, consider changing the input scaleFactor and/or initial minNeighbors value. If neither 1) or 2) applies, then there is an unknown bug somewhere that should be investigated!!!\\\")\\n if verbose:\\n print(f\\\"minNeighbors = {params_new['minNeighbors']}\\\")\\n detected_objects = haar_cascade.detectMultiScale(gray, **params_new)\\n num_detected = len(detected_objects)\\n if num_detected == num_detected_prev and boost_flag:\\n boost_factor += 1\\n else:\\n boost_factor = 1\\n num_detected_prev = num_detected\\n if verbose:\\n print(f\\\"Final # of Objects Detected = {num_detected}\\\")\\n return detected_objects\",\n \"def visualize_detection(self, img, dets, seg, classes=[], thresh=0.6):\\n from dataset.cs_labels import labels\\n lut = np.zeros((256,3))\\n for l in labels:\\n if l.trainId<255 and l.trainId>=0:\\n lut[l.trainId,:]=list(l.color)\\n palette = lut\\n # det2seg = {0:6,1:7,2:11,3:12,4:13,5:14,6:15,7:16,8:17,9:18,}\\n det2seg = {0:11,1:12,2:13,3:14,4:15,5:16,6:17,7:18,}\\n \\n import cv2\\n import random\\n tic = time.time()\\n color_white = (255, 255, 255)\\n im = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # change to bgr\\n yscale, xscale, ch = im.shape\\n color = (0,0,128)\\n fontFace = cv2.FONT_HERSHEY_PLAIN\\n fontScale = .8*(yscale/float(320))\\n thickness = 2 if yscale>320 else 1\\n idx = np.argsort(dets[:,6],axis=0)[::-1] ## draw nearest first !!\\n dets = dets[idx,:]\\n for det in dets:\\n cls_id = int(det[0])\\n bbox = [det[2]*xscale,det[3]*yscale,det[4]*xscale,det[5]*yscale]\\n score = det[1]\\n distance = det[-1]\\n if score > thresh:\\n bbox = map(int, bbox)\\n color = palette[det2seg[int(det[0])],(2,1,0)]\\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=thickness)\\n text = '%s %.0fm' % (short_class_name[classes[cls_id]], distance*255., )\\n textSize, baseLine = cv2.getTextSize(text, fontFace, fontScale, thickness=1)\\n cv2.rectangle(im, (bbox[0], bbox[1]-textSize[1]), (bbox[0]+textSize[0], bbox[1]), color=(128,0,0), thickness=-1)\\n cv2.putText(im, text, (bbox[0], bbox[1]),\\n color=color_white, fontFace=fontFace, fontScale=fontScale, thickness=1)\\n disp = im.copy()\\n if False: #disp.shape[1]>1000:\\n hh, ww, ch = disp.shape\\n resized = cv2.resize(disp, (int(round(ww*.92)),int(round(hh*.92))))\\n else:\\n resized = disp\\n cv2.imshow(\\\"result\\\", resized)\\n # cv2.imwrite(\\\"data/cityscapes/Results/stuttgart_%06d.png\\\" % (self.imgidx,), resized)\\n # self.imgidx += 1\",\n \"def classify(img, c_model):\\n #global class_graph\\n\\n #img = load_img(im_path,target_size=(input_height, input_width))\\n #img = img_to_array(img)\\n im_size = 128\\n # resize \\n\\n img = cv2.resize(img, (im_size,im_size))\\n\\n img = img.astype(\\\"float\\\") / 255.0\\n img = np.expand_dims(img, axis=0)\\n with class_graph.as_default():\\n predictions = c_model.predict(img)[0]\\n\\n return predictions\",\n \"def get_classification(self, image):\\n\\n\\tif 'session' in locals() and session is not None:\\n \\t print('Close interactive session')\\n session.close()\\n\\n time_start = time.time()\\n #TODO implement light color prediction\\n #image_np = self.__preprocess_image(image)\\n \\timage_np = image \\n \\n \\t# Expand dimensions since the model expects images to have shape: [1, None, None, 3]\\n image_np_expanded = np.expand_dims(image_np, axis=0)\\n time0 = time.time()\\n\\n # Actual detection.\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n\\n time1 = time.time()\\n\\n output = self.__postprocessing_detected_box(scores[0], classes[0])\\n rospy.loginfo('Time in seconds' + str(time1-time_start)+' Result:'+self.__traffic_id_to_name(output))\\n return output\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71595085","0.7112627","0.7053825","0.695533","0.6803062","0.6613106","0.65618676","0.6435698","0.6388294","0.6292531","0.62065536","0.6154667","0.6117337","0.6116278","0.6087541","0.6083871","0.6029203","0.59899825","0.5947565","0.59351975","0.59153056","0.5905604","0.5905474","0.5888767","0.58779997","0.587066","0.58599794","0.5828943","0.582773","0.5816881","0.5748792","0.5747216","0.57447904","0.5739697","0.5731951","0.57189095","0.5698644","0.56901395","0.56874084","0.56758755","0.56744546","0.5673126","0.5663616","0.56492144","0.5638978","0.56340915","0.563301","0.5607951","0.56010497","0.5587516","0.5567453","0.55544","0.5550566","0.55445635","0.55193305","0.5518717","0.54831886","0.5474932","0.5467454","0.54655766","0.5465564","0.5455052","0.5449428","0.5444627","0.5442575","0.5438566","0.5432638","0.5421888","0.5420303","0.5418881","0.53786635","0.5370426","0.5369361","0.5327969","0.5324702","0.5322059","0.53133607","0.53118616","0.5304865","0.53025764","0.5301505","0.52968186","0.5294872","0.5287007","0.5284486","0.5283038","0.52794105","0.52788097","0.5278097","0.5277754","0.52647346","0.5264531","0.52641445","0.5260493","0.52598304","0.52583313","0.52511305","0.5250498","0.5247501","0.52456146"],"string":"[\n \"0.71595085\",\n \"0.7112627\",\n \"0.7053825\",\n \"0.695533\",\n \"0.6803062\",\n \"0.6613106\",\n \"0.65618676\",\n \"0.6435698\",\n \"0.6388294\",\n \"0.6292531\",\n \"0.62065536\",\n \"0.6154667\",\n \"0.6117337\",\n \"0.6116278\",\n \"0.6087541\",\n \"0.6083871\",\n \"0.6029203\",\n \"0.59899825\",\n \"0.5947565\",\n \"0.59351975\",\n \"0.59153056\",\n \"0.5905604\",\n \"0.5905474\",\n \"0.5888767\",\n \"0.58779997\",\n \"0.587066\",\n \"0.58599794\",\n \"0.5828943\",\n \"0.582773\",\n \"0.5816881\",\n \"0.5748792\",\n \"0.5747216\",\n \"0.57447904\",\n \"0.5739697\",\n \"0.5731951\",\n \"0.57189095\",\n \"0.5698644\",\n \"0.56901395\",\n \"0.56874084\",\n \"0.56758755\",\n \"0.56744546\",\n \"0.5673126\",\n \"0.5663616\",\n \"0.56492144\",\n \"0.5638978\",\n \"0.56340915\",\n \"0.563301\",\n \"0.5607951\",\n \"0.56010497\",\n \"0.5587516\",\n \"0.5567453\",\n \"0.55544\",\n \"0.5550566\",\n \"0.55445635\",\n \"0.55193305\",\n \"0.5518717\",\n \"0.54831886\",\n \"0.5474932\",\n \"0.5467454\",\n \"0.54655766\",\n \"0.5465564\",\n \"0.5455052\",\n \"0.5449428\",\n \"0.5444627\",\n \"0.5442575\",\n \"0.5438566\",\n \"0.5432638\",\n \"0.5421888\",\n \"0.5420303\",\n \"0.5418881\",\n \"0.53786635\",\n \"0.5370426\",\n \"0.5369361\",\n \"0.5327969\",\n \"0.5324702\",\n \"0.5322059\",\n \"0.53133607\",\n \"0.53118616\",\n \"0.5304865\",\n \"0.53025764\",\n \"0.5301505\",\n \"0.52968186\",\n \"0.5294872\",\n \"0.5287007\",\n \"0.5284486\",\n \"0.5283038\",\n \"0.52794105\",\n \"0.52788097\",\n \"0.5278097\",\n \"0.5277754\",\n \"0.52647346\",\n \"0.5264531\",\n \"0.52641445\",\n \"0.5260493\",\n \"0.52598304\",\n \"0.52583313\",\n \"0.52511305\",\n \"0.5250498\",\n \"0.5247501\",\n \"0.52456146\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69261765"},"document_rank":{"kind":"string","value":"4"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":234,"numItemsPerPage":100,"numTotalItems":95772,"offset":23400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjcwNzM0OCwianRpIjoiY2VmZjZhMTEtNTVlMy00OGVhLTlhMWUtZDU5ZmU1ODFlNmQ4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MTA5NDgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.irevc7rpbGOtaUkI1CVCQs-kw6LnJRVYUZVihzby_ckiRZERV8DOtUQpEV4jh9BWylphbgCxoVjO8ouqCYGlCg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
This function will be evaluated on all GPUs. | def closure(model, criterion, optimizer, target_grad, target_gnorm): # noqa: D401
outputs = model(inputs)
if self.args.target_criterion in ['cw', 'carlini-wagner']:
criterion = cw_loss
else:
pass # use the default for untargeted or targeted cross ent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _gpu_and_random(self, exprs):\n if not GPU:\n return False\n if not all(tell_deterministic(i) for i in exprs):\n return True\n\n return False",
"def main():\n\n # Create an empty array to hold our points.\n n = gpuarray.zeros(shape=(x, y, z),\n ... | [
"0.67035437",
"0.65965104",
"0.65801316",
"0.65305763",
"0.64696866",
"0.63764197",
"0.6337298",
"0.6332883",
"0.623927",
"0.62189025",
"0.6205842",
"0.618085",
"0.61776066",
"0.615781",
"0.6089916",
"0.6078713",
"0.6078713",
"0.6073123",
"0.6054747",
"0.60293716",
"0.6015013... | 0.0 | -1 |
Compute the blind passenger loss term. | def _passenger_loss(self, poison_grad, target_grad, target_gnorm):
passenger_loss = 0
poison_norm = 0
SIM_TYPE = ['similarity', 'similarity-narrow', 'top5-similarity', 'top10-similarity', 'top20-similarity']
if self.args.loss == 'top10-similarity':
_, indices = torch.topk(to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_loss(self):",
"def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\n return losses['total']",
"def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\n return self.descent.calc_loss(x,... | [
"0.7101872",
"0.7088875",
"0.7031537",
"0.6961103",
"0.68990636",
"0.68538445",
"0.6827168",
"0.6820173",
"0.6786275",
"0.678076",
"0.67776346",
"0.67702687",
"0.673941",
"0.67255217",
"0.67128986",
"0.6688643",
"0.6676217",
"0.666976",
"0.6667273",
"0.66558874",
"0.66343457"... | 0.6535987 | 27 |
Implement the closure here. | def _define_objective(self, inputs, labels, targets, intended_classes, true_classes):
def closure(model, criterion, optimizer, target_grad, target_gnorm):
"""This function will be evaluated on all GPUs.""" # noqa: D401
outputs = model(inputs)
if self.args.target_criterion in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closure(self, t):\n raise NotImplementedError",
"def callback(self):\n pass # pragma: no cover",
"def __call__(self):\n\t\treturn",
"def __call__( self ):\n pass",
"def apply(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def closure(self):\n return... | [
"0.72084713",
"0.67918205",
"0.66439474",
"0.6594649",
"0.6570198",
"0.65522903",
"0.65522903",
"0.6530278",
"0.6526465",
"0.6436523",
"0.64173025",
"0.64173025",
"0.64173025",
"0.64173025",
"0.64173025",
"0.6416854",
"0.64145666",
"0.6391834",
"0.63399154",
"0.63399154",
"0.... | 0.0 | -1 |
This function will be evaluated on all GPUs. | def closure(model, criterion, optimizer, target_grad, target_gnorm): # noqa: D401
outputs = model(inputs)
if self.args.target_criterion in ['cw', 'carlini-wagner']:
criterion = cw_loss
else:
pass # use the default for untargeted or targeted cross ent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _gpu_and_random(self, exprs):\n if not GPU:\n return False\n if not all(tell_deterministic(i) for i in exprs):\n return True\n\n return False",
"def main():\n\n # Create an empty array to hold our points.\n n = gpuarray.zeros(shape=(x, y, z),\n ... | [
"0.67035437",
"0.65965104",
"0.65801316",
"0.65305763",
"0.64696866",
"0.63764197",
"0.6337298",
"0.6332883",
"0.623927",
"0.62189025",
"0.6205842",
"0.618085",
"0.61776066",
"0.615781",
"0.6089916",
"0.6078713",
"0.6078713",
"0.6073123",
"0.6054747",
"0.60293716",
"0.6015013... | 0.0 | -1 |
Enforce batchwise privacy if necessary. This is attacking a defense discussed in Hong et al., 2020 We enforce privacy on mini batches instead of instances to cope with effects on batch normalization This is reasonble as Hong et al. discuss that defense against poisoning mostly arises from the addition of noise to the g... | def _hide_gradient(self, gradient_list):
if self.args.gradient_clip is not None:
total_norm = torch.norm(torch.stack([torch.norm(grad) for grad in gradient_list]))
clip_coef = self.args.gradient_clip / (total_norm + 1e-6)
if clip_coef < 1:
for grad in gradient... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_keras_unsafe_batch_size():\n model, X, y, Xval, yval = make_small_model()\n\n loss = tf.keras.losses.CategoricalCrossentropy(\n from_logits=False, reduction=tf.losses.Reduction.NONE\n )\n model.compile(loss=loss, optimizer=None)\n\n isDP, msg = safekeras.check_optimizer_is_DP(model.o... | [
"0.59551156",
"0.5798743",
"0.559241",
"0.5435405",
"0.5397174",
"0.5382515",
"0.531263",
"0.5305372",
"0.52814037",
"0.5258523",
"0.5241897",
"0.5238457",
"0.52154946",
"0.51913124",
"0.5172364",
"0.51606447",
"0.51105905",
"0.51038843",
"0.5099438",
"0.50854",
"0.5076326",
... | 0.50958407 | 19 |
tokenized_sentence = ["tu", "que", "tal"] all_words = ["tu", "yo", "soy", "que", "tal"] bag = [ 1, 0, 0, 1, 1] | def bag_of_words(tokenized_sentence, all_words):
tokenized_sentence = [stem(w) for w in tokenized_sentence]
#print(tokenized_sentence)
bag = np.zeros_like(all_words, dtype=np.float32)
for idx, w in enumerate(all_words):
if w in tokenized_sentence:
bag[idx] = 1.0
return bag | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bag_of_words(batch, TEXT):\n V = len(TEXT.vocab)\n X = torch.zeros(batch.text.size(0), V)\n ones = torch.ones(batch.text.size(1))\n for b in range(batch.text.size(0)):\n X[b].index_add_(0, batch.text.data[b], ones)\n X[b][TEXT.vocab.stoi['<pad>']] = 0\n X = Variable(X, requires_gra... | [
"0.7064958",
"0.6989011",
"0.6753921",
"0.66266555",
"0.6409904",
"0.63231957",
"0.6267341",
"0.62106866",
"0.6205491",
"0.6204041",
"0.6201656",
"0.61629564",
"0.61408895",
"0.60988027",
"0.6071161",
"0.60488117",
"0.60472023",
"0.59949446",
"0.59798604",
"0.5959912",
"0.595... | 0.8335468 | 0 |
Return a list of tuple pairs from a string of commaseparated pairs | def extract_pairs(raw):
try:
pairs = list(set([(p.split("-")[0].strip().upper(), p.split("-")[1].strip().upper()) for p in raw.split(",")]))
except IndexError as e:
raise IndexError("Invalid pair")
for x, y in pairs:
if not (len(x) > 1 and len(y) > 1):
raise Exception(f'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _pairs(content: str) -> Generator[Tuple[Any, Any], None, None]:\n if not content.strip():\n return\n\n for pair in content.split(\",\"):\n\n x, *y = pair.split(\":\", maxsplit=1)\n if len(y) == 0:\n raise ValueError(f\"Cannot parse pair {pair}\")\n\n yield x.strip()... | [
"0.7547629",
"0.7007731",
"0.6750094",
"0.658827",
"0.6409757",
"0.64013463",
"0.63092816",
"0.6293765",
"0.62603337",
"0.6251687",
"0.62503666",
"0.6168677",
"0.6142506",
"0.6126788",
"0.6120142",
"0.6057803",
"0.6056945",
"0.5997375",
"0.594228",
"0.5908846",
"0.58880675",
... | 0.6935102 | 2 |
|coro| Calls the internal callback that the command holds. | async def __call__(self, *args, **kwargs):
if self.cog is not None:
# manually pass the cog class to the coro instead of calling it as a method
return await self.callback(self.cog, *args, **kwargs)
else:
return await self.callback(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perform_callback(self, *args, **kwargs):\n pass",
"async def _run_command(self, command, *args, **kwargs):\n pass",
"def execute(self):\n return self.callback(*self.args)",
"async def exec(self, *args, **kwargs) -> None:\n if self.is_usable:\n if self.is_limited:\n ... | [
"0.69243807",
"0.6909893",
"0.6818065",
"0.67567855",
"0.6717582",
"0.66642964",
"0.66566145",
"0.6656008",
"0.66115445",
"0.66091347",
"0.6548687",
"0.6502713",
"0.64771914",
"0.64045286",
"0.63988125",
"0.63556695",
"0.63556355",
"0.63522184",
"0.6235755",
"0.6161218",
"0.6... | 0.6829955 | 2 |
Creates a copy of this command. Returns | def copy(self):
ret = self.__class__(self.callback, **self.__original_kwargs__)
return self._ensure_assignment_on_copy(ret) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy (self):\n return self.__class__(self.name, self[:])",
"def copy(self):\n new = object.__new__(type(self))\n new.bot = self.bot\n new.description = self.description\n new.icon_hash = self.icon_hash\n new.icon_type = self.icon_type\n new.id = 0\n new... | [
"0.70498085",
"0.6929576",
"0.69185376",
"0.67951876",
"0.6781262",
"0.67583",
"0.669616",
"0.6664715",
"0.6664715",
"0.66360825",
"0.6626673",
"0.6619382",
"0.66085666",
"0.6604005",
"0.6583924",
"0.65665233",
"0.6523402",
"0.6514677",
"0.64874953",
"0.6483554",
"0.64349014"... | 0.0 | -1 |
A decorator that registers a coroutine as a preinvoke hook. A preinvoke hook is called directly before the command is called. This makes it a useful function to set up database connections or any type of set up required. | def before_invoke(self, coro):
if not asyncio.iscoroutinefunction(coro):
raise TypeError('The pre-invoke hook must be a coroutine.')
self._before_invoke = coro
return coro | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def before_invoke(coro) -> Callable[[T], T]:\n def decorator(func: Union[Command, CoroFunc]) -> Union[Command, CoroFunc]:\n if isinstance(func, Command):\n func.before_invoke(coro)\n else:\n func.__before_invoke__ = coro\n return func\n return decorator # type: ign... | [
"0.711384",
"0.59254164",
"0.59139216",
"0.57862735",
"0.57862735",
"0.57862735",
"0.57862735",
"0.5783765",
"0.56661844",
"0.55336636",
"0.54575396",
"0.5412497",
"0.535912",
"0.5343143",
"0.5328596",
"0.5258286",
"0.5252766",
"0.5236413",
"0.5234541",
"0.5177922",
"0.516268... | 0.7430255 | 0 |
A decorator that registers a coroutine as a postinvoke hook. A postinvoke hook is called directly after the command is called. This makes it a useful function to cleanup database connections or any type of clean up required. | def after_invoke(self, coro):
if not asyncio.iscoroutinefunction(coro):
raise TypeError('The post-invoke hook must be a coroutine.')
self._after_invoke = coro
return coro | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_invoke(coro) -> Callable[[T], T]:\n def decorator(func: Union[Command, CoroFunc]) -> Union[Command, CoroFunc]:\n if isinstance(func, Command):\n func.after_invoke(coro)\n else:\n func.__after_invoke__ = coro\n return func\n return decorator # type: ignore... | [
"0.7060543",
"0.59133196",
"0.5863492",
"0.57352626",
"0.56779206",
"0.563653",
"0.55416155",
"0.5520004",
"0.5520004",
"0.5520004",
"0.5520004",
"0.5489191",
"0.5475493",
"0.54560333",
"0.54542017",
"0.5424057",
"0.5418961",
"0.5323915",
"0.5317458",
"0.5298286",
"0.5239417"... | 0.7256072 | 0 |
|coro| Checks if the command can be executed by checking all the predicates | async def can_run(self, ctx: Context) -> bool:
if not self.enabled:
raise DisabledCommand(f'{self.name} command is disabled')
original = ctx.command
ctx.command = self
try:
if not await ctx.bot.can_run(ctx):
raise CheckFailure(f'The global check... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_commands(self):\n pass",
"def run_command_check(self):\n pass",
"def is_command(oin, env, pred_name: YPredName, arg: Any=None):\n return (env.check_predicate(obj, pred_name, arg) for obj in oin)",
"def is_command_ancillary(args):\n # pylint: disable=bad-continuation\n if (\n ... | [
"0.7544951",
"0.7229583",
"0.7154898",
"0.6828592",
"0.6776484",
"0.6664218",
"0.65445536",
"0.6532735",
"0.6488253",
"0.64757514",
"0.6359895",
"0.6333302",
"0.6325952",
"0.6274989",
"0.6268233",
"0.62203294",
"0.6179746",
"0.616666",
"0.61375",
"0.6132663",
"0.6086138",
"... | 0.6836468 | 3 |
An iterator that recursively walks through all commands and subcommands. Yields | def walk_commands(self) -> typing.Generator[Command, None, None]:
for command in self.commands:
yield command
if isinstance(command, Group):
yield from command.walk_commands() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n for node in self.grammar.walk():\n yield node",
"def HierarchyIterator(obj):\n while obj:\n yield obj\n for opChild in SplineInputGeneratorHelper.HierarchyIterator(obj.GetDown()):\n yield opChild\n obj = obj.GetNext()"... | [
"0.69049597",
"0.6855705",
"0.67742354",
"0.67373574",
"0.6698454",
"0.6655534",
"0.6623079",
"0.65826356",
"0.65400165",
"0.650673",
"0.63782173",
"0.63522226",
"0.63168263",
"0.63032573",
"0.63010323",
"0.62850904",
"0.62850904",
"0.626276",
"0.6249921",
"0.62281144",
"0.61... | 0.75511664 | 0 |
A decorator that registers a coroutine as a preinvoke hook. This allows you to refer to one before invoke hook for several commands that do not have to be within the same cog. Example | def before_invoke(coro) -> Callable[[T], T]:
def decorator(func: Union[Command, CoroFunc]) -> Union[Command, CoroFunc]:
if isinstance(func, Command):
func.before_invoke(coro)
else:
func.__before_invoke__ = coro
return func
return decorator # type: ignore | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def before_invoke(self, coro):\n if not asyncio.iscoroutinefunction(coro):\n raise TypeError('The pre-invoke hook must be a coroutine.')\n\n self._before_invoke = coro\n return coro",
"def wrap_before(before, condition=lambda *args, **kwargs: True):\n def decorator(func):\n ... | [
"0.7762231",
"0.61355424",
"0.6063686",
"0.5962607",
"0.58490914",
"0.5809584",
"0.5795975",
"0.5628273",
"0.55104494",
"0.55104494",
"0.55104494",
"0.55104494",
"0.54770267",
"0.5420125",
"0.53899693",
"0.53138167",
"0.53052264",
"0.52775484",
"0.52747756",
"0.5244982",
"0.5... | 0.7769411 | 0 |
A decorator that registers a coroutine as a postinvoke hook. This allows you to refer to one after invoke hook for several commands that do not have to be within the same cog. | def after_invoke(coro) -> Callable[[T], T]:
def decorator(func: Union[Command, CoroFunc]) -> Union[Command, CoroFunc]:
if isinstance(func, Command):
func.after_invoke(coro)
else:
func.__after_invoke__ = coro
return func
return decorator # type: ignore | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_invoke(self, coro):\n if not asyncio.iscoroutinefunction(coro):\n raise TypeError('The post-invoke hook must be a coroutine.')\n\n self._after_invoke = coro\n return coro",
"def Postcall(function_to_call_later): \n def postcall_inside(fun): \n @functo... | [
"0.7621359",
"0.6003703",
"0.590855",
"0.580963",
"0.56406933",
"0.5633439",
"0.5529226",
"0.551219",
"0.5412582",
"0.53565824",
"0.5354295",
"0.5315982",
"0.53044456",
"0.5290917",
"0.52646506",
"0.5262968",
"0.5256531",
"0.52481365",
"0.52188635",
"0.5216198",
"0.5194705",
... | 0.77887046 | 0 |
Initialize your data structure here. | def __init__(self):
self.hashmap = {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Returns true if the message should be printed in the given timestamp, otherwise returns false. If this method returns false, the message will not be printed. The timestamp is in seconds granularity. | def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
if message not in self.hashmap:
self.hashmap[message] = timestamp
return True
elif timestamp - self.hashmap[message] >= 10:
self.hashmap[message] = timestamp
return True
return Fal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shouldPrintMessage(self, timestamp, message):\n if message in self.msg_dict:\n pst_ts = self.msg_dict[message]\n if timestamp - pst_ts >= 10:\n self.msg_dict[message] = timestamp\n return True\n else:\n return False\n \... | [
"0.81442153",
"0.81045413",
"0.80361164",
"0.7786668",
"0.7709378",
"0.7697737",
"0.7580134",
"0.74628806",
"0.73462576",
"0.70301074",
"0.6919817",
"0.6418114",
"0.6398993",
"0.61138827",
"0.6103651",
"0.607633",
"0.60022604",
"0.5952176",
"0.59207034",
"0.5854169",
"0.58502... | 0.72041863 | 9 |
A lightweight wrapper around `get_context()`. While this used to be the canonical method of instantiating a DataContext before 0.15.40, it is now recommended to use `get_context()`. | def BaseDataContext( # noqa: PLR0913
project_config: Union[DataContextConfig, Mapping],
context_root_dir: Optional[PathStr] = None,
runtime_environment: Optional[dict] = None,
cloud_mode: bool = False,
cloud_config: Optional[GXCloudConfig] = None,
# Deprecated as of 0.15.37
ge_cloud_mode: b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_context(cls):\n # create context for current thread if there is none yet\n thread_id = cls._get_thread_id()\n if thread_id not in cls._current_context:\n cls._current_context[thread_id] = DataContext()\n \n # return the requested DataContext\n return cls... | [
"0.78117675",
"0.75992185",
"0.6992268",
"0.6849802",
"0.68103427",
"0.66601473",
"0.66341734",
"0.65982026",
"0.6576827",
"0.6547928",
"0.64481944",
"0.6436456",
"0.63984936",
"0.6376657",
"0.6315649",
"0.6252722",
"0.62010777",
"0.61932164",
"0.61883074",
"0.6184539",
"0.61... | 0.0 | -1 |
Clips the given position to the min and max values which are given by the configuration. | def clipPosLimits(self, pos):
return max(min(self.pos_max, pos), self.pos_min) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clip(self):\n if self._value < self.lowBound:\n self._value = self.lowBound\n elif self._value > self.upBound:\n self._value = self.upBound",
"def _update_limits(self):\n if self.pos_x > self.max_x:\n self.max_x = self.pos_x\n if self.pos_y > self.... | [
"0.6378307",
"0.601431",
"0.60079855",
"0.5891191",
"0.5891191",
"0.5858452",
"0.5838469",
"0.5741724",
"0.5692912",
"0.56625235",
"0.56378406",
"0.56049365",
"0.5560278",
"0.55355376",
"0.55305564",
"0.5506636",
"0.54941773",
"0.5478835",
"0.5417553",
"0.5407499",
"0.5398159... | 0.549168 | 17 |
Clips the given position to the min and max values which are read from the motors. | def clipRawLimits(self, raw):
return max(min(self.raw_max, raw), self.raw_min) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clip(self):\n if self._value < self.lowBound:\n self._value = self.lowBound\n elif self._value > self.upBound:\n self._value = self.upBound",
"def _update_limits(self):\n if self.pos_x > self.max_x:\n self.max_x = self.pos_x\n if self.pos_y > self.... | [
"0.58154917",
"0.5753531",
"0.56642437",
"0.5660898",
"0.5656791",
"0.5598197",
"0.55842364",
"0.5549174",
"0.55371904",
"0.55026674",
"0.54736996",
"0.547152",
"0.5464527",
"0.54394066",
"0.54118705",
"0.54025453",
"0.53908134",
"0.5382611",
"0.5371208",
"0.5355029",
"0.5333... | 0.52654696 | 25 |
Returns the raw motor angle. | def raw(self):
return float(self.uw.send(self.name + '.val')[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_angle(self):\n return self.bot_client.send_command(_Command.GetAngle)",
"def getAngle(self):\n return self.articulateEncoder.getDistance()+self.angleOffset",
"def angle(self):\n if self.__trigger == gyro_trigger_mode.GET_ANGLE_TRIGGER_READ:\n self.read_and_update_angle()... | [
"0.7897493",
"0.7447755",
"0.74181837",
"0.7340101",
"0.7331262",
"0.7290696",
"0.7290696",
"0.7290696",
"0.7280038",
"0.7271251",
"0.72595936",
"0.7241423",
"0.72328305",
"0.71845204",
"0.7175799",
"0.7175799",
"0.70919544",
"0.6964341",
"0.69560325",
"0.6882237",
"0.6830001... | 0.0 | -1 |
Sets the raw motor angle to raw. | def raw(self, raw):
self.uw.send('%s.val = %.4f' % (self.name, self.clipRawLimits(raw))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_angle(self, value):\n if not -90 <= value <= 90:\n raise ValueError('Servo angle must be between -90 and 90 degrees')\n self.duty_cycle = ...",
"def set_angle(self, ang):\n if ang < 0:\n ang = 0\n elif ang > 180:\n ang = 180\n dutyCycle ... | [
"0.6217187",
"0.6139621",
"0.5981916",
"0.59780204",
"0.5968334",
"0.5963124",
"0.5929604",
"0.58463824",
"0.58386225",
"0.58235294",
"0.5821314",
"0.5779344",
"0.577006",
"0.57593364",
"0.57482916",
"0.57446665",
"0.5732732",
"0.57217443",
"0.5697634",
"0.56790173",
"0.56654... | 0.0 | -1 |
Returns the position angle. | def pos(self):
return (self.raw - self.raw_zero) / self.ratio | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle(self):\n return self._angle",
"def angle(self):\n return self._angle",
"def angle(self):\n return self._angle",
"def angle(self):\n return math.degrees(math.atan2(self[1], self[0]))",
"def angle(self) -> float:\n return self._angle",
"def angle(self) -> float:... | [
"0.7897296",
"0.7897296",
"0.7897296",
"0.78602666",
"0.78450084",
"0.78450084",
"0.7791315",
"0.7785088",
"0.77567",
"0.77245075",
"0.7694945",
"0.7674423",
"0.76514906",
"0.76398444",
"0.7619912",
"0.7619509",
"0.761692",
"0.7377269",
"0.73328733",
"0.7306481",
"0.7301534",... | 0.0 | -1 |
Sets the position angle by using the MoveSpeed method which will generate an appropriate trajectory. | def pos(self, value):
self.uw.send('%s.val = %.4f smooth:2' % (self.name, (self.clipPosLimits(value) * self.ratio) + self.raw_zero)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_angle(self, angle=0.0):\n self.angle = angle",
"def setAngle(self, angle):\n self.vector.angle = angle",
"def angle(self, angle):\n self._angle = angle\n self.x_rate = self._rate * cos(self._angle)\n self.y_rate = self._rate * sin(self._angle)",
"def setAngle(self,a... | [
"0.713275",
"0.7047413",
"0.6900193",
"0.68479806",
"0.67285573",
"0.67080504",
"0.6651994",
"0.6613435",
"0.65998375",
"0.6586775",
"0.6586668",
"0.6583904",
"0.6562857",
"0.6562816",
"0.6555339",
"0.65001845",
"0.64947605",
"0.6476751",
"0.6425671",
"0.64084893",
"0.640674"... | 0.0 | -1 |
Moves the joint to it's center position which is based on the configuration. | def center(self):
if self.pos != 0.0:
self.pos = 0.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center(self, destination):\n self.move(destination=destination, origin=self.center)",
"def __moveCenterTo(self, x, y):\n x0, y0, w, h = self.currentBox\n x2, y2 = x - (w/2), y - (h/2)\n self.__moveTo(x2, y2)",
"def move(self, dt):\n lims = self.settings['agent']['jointLim... | [
"0.68540615",
"0.66069347",
"0.63885736",
"0.63441104",
"0.6240075",
"0.61633927",
"0.6161882",
"0.60907334",
"0.6087191",
"0.6079575",
"0.60515106",
"0.599599",
"0.5902333",
"0.5902333",
"0.5899517",
"0.5879379",
"0.5857834",
"0.5857834",
"0.5857834",
"0.5846521",
"0.5834355... | 0.6212106 | 5 |
Moves the joint in position over time. | def move(self, position, time):
self.uw.send(self.name + '.Move(%.4f, %.4f)' % (self.clipLimits(position), time), time) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, dt):\n lims = self.settings['agent']['jointLimits']\n # print '[move] curr joint Angle:'\n # print self.jointAngle\n # print '[move] curr speed:'\n # print self.speed\n\n J = self.jointAngle + dt * np.array(self.speed)\n self.jointAngle[0] = min(max(J... | [
"0.77453464",
"0.7130474",
"0.7102428",
"0.66326016",
"0.65695906",
"0.65682214",
"0.656399",
"0.65440696",
"0.65246534",
"0.6487018",
"0.6408533",
"0.6407845",
"0.64014333",
"0.6378285",
"0.63696784",
"0.6363772",
"0.6341952",
"0.6338761",
"0.63288975",
"0.632679",
"0.632376... | 0.6202988 | 30 |
Initializes a storage merge reader. | def __init__(self, session, storage_writer, task_storage_reader):
super(StorageMergeReader, self).__init__()
self._active_container_type = None
self._active_generator = None
self._container_types = []
self._event_data_identifier_mappings = {}
self._event_data_parser_mappings = {}
self._event... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n\n self.reader = reader.Reader()",
"def __init__(self, storage_writer, task, redis_client=None):\n super(RedisMergeReader, self).__init__(storage_writer)\n self._active_container_type = None\n self._container_types = []\n self._active_cursor = 0\n self._add_active_conta... | [
"0.62885654",
"0.58362806",
"0.57856005",
"0.5741826",
"0.5728234",
"0.5686032",
"0.5671583",
"0.55968064",
"0.55951667",
"0.55562574",
"0.5551261",
"0.5526546",
"0.5510841",
"0.54997456",
"0.54607743",
"0.54495597",
"0.54392564",
"0.54389495",
"0.5437427",
"0.5426284",
"0.53... | 0.70713705 | 0 |
Closes the merge reader. | def Close(self):
self._task_storage_reader.Close()
self._task_storage_reader = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n self.read1_batch = None\n self.read2_batch = None\n self.writer.close()",
"def close(self) -> None:\n self._data_read_thread_exit.set()\n self._plc_raw_reader.close()",
"def close(self):\n\n self.r.close()",
"async def close(self):\n self.wr... | [
"0.666458",
"0.6577255",
"0.65621406",
"0.63686776",
"0.6257405",
"0.612783",
"0.6073545",
"0.60268825",
"0.6012104",
"0.597271",
"0.59165436",
"0.59048855",
"0.58956796",
"0.58956796",
"0.58783615",
"0.58691126",
"0.58595616",
"0.5842735",
"0.5793702",
"0.57903874",
"0.57751... | 0.5807931 | 18 |
Adds an attribute container. | def AddAttributeContainer(self, container):
if container.CONTAINER_TYPE == self._CONTAINER_TYPE_EVENT:
event_data_identifier = container.GetEventDataIdentifier()
event_data_lookup_key = event_data_identifier.CopyToString()
event_data_identifier = self._event_data_identifier_mappings.get(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def AddAttributeContainer(self, container):\n self._RaiseIfNotWritable()\n\n self._storage_file.AddAttributeContainer(container)\n\n if container.CONTAINER_TYPE == self._CONTAINER_TYPE_ANALYSIS_REPORT:\n self._UpdateAnalys... | [
"0.75477207",
"0.7508515",
"0.74494576",
"0.6670482",
"0.66451406",
"0.6619809",
"0.64255786",
"0.63276106",
"0.63160694",
"0.6293641",
"0.6259919",
"0.62502015",
"0.61483186",
"0.6022993",
"0.6013706",
"0.59946126",
"0.5993446",
"0.5952222",
"0.5945296",
"0.5908125",
"0.5889... | 0.73643523 | 3 |
Reads attribute containers from a task store into the writer. | def MergeAttributeContainers(self, maximum_number_of_containers=0):
if not self._container_types:
self._container_types = list(self._CONTAINER_TYPES)
if not self._active_container_type:
logger.debug('Starting merge')
else:
logger.debug('Continuing merge of: {0:s}'.format(
self._... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_attributes(self, dataset):\n if 'attributes' in self.configs:\n for key, value in self.configs['attributes'].items():\n setattr(dataset, key, value)",
"def testGetAttributeContainers(self):\n redis_client = self._CreateRedisClient()\n\n test_store = redis_store.Red... | [
"0.5800981",
"0.5413162",
"0.5282194",
"0.4992944",
"0.4942496",
"0.4919056",
"0.4915868",
"0.48092586",
"0.47643942",
"0.4708785",
"0.46842325",
"0.46792078",
"0.46767762",
"0.4647595",
"0.46118864",
"0.4574277",
"0.45592013",
"0.45582253",
"0.4555862",
"0.4551604",
"0.45465... | 0.0 | -1 |
Handle page head and create dict with different content | def handle_page_head(self, head_content):
return_dict = {}
return_dict['title'] = self.find_in_content(r'title:.+', head_content)
return_dict['permalink'] = self.find_in_content(r'permalink:.+',
head_content)
return return_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ParsePageHead(read):\n page_head = {}\n result = struct.unpack_from(PageHeadFormat, read, 0)\n for i in xrange(len(PageHeadProperties)):\n page_head[PageHeadProperties[i]] = result[i]\n return page_head",
"def handle_page_body(self, body_content):\n return_dict = {}\n return_... | [
"0.65806377",
"0.6083205",
"0.59432834",
"0.59213173",
"0.5893205",
"0.58655334",
"0.5822796",
"0.5818106",
"0.58166486",
"0.57890755",
"0.57307625",
"0.5705943",
"0.5701683",
"0.5639737",
"0.5633458",
"0.56205946",
"0.557755",
"0.5573049",
"0.5549238",
"0.5528069",
"0.552551... | 0.8366756 | 0 |
Handle page body and create page dict | def handle_page_body(self, body_content):
return_dict = {}
return_dict['content'] = self.markdown_to_html(body_content)
return return_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_mapping_page(self, id, body):\n info = {}\n info['original'] = self.__re_search(body, *self.regx['original'])\n info['save'] = self.__re_search(body, *self.regx['save'])\n info['price'] = self.__re_search(body, *self.regx['price'])\n info['rebate'] = self.__re_search(bo... | [
"0.64590585",
"0.6278418",
"0.6139448",
"0.5948847",
"0.5872562",
"0.5811106",
"0.57711333",
"0.57591534",
"0.5752565",
"0.57495147",
"0.5747665",
"0.5722854",
"0.5712628",
"0.571118",
"0.5696923",
"0.5694322",
"0.5614354",
"0.56108755",
"0.56095475",
"0.5606405",
"0.5568982"... | 0.7880545 | 0 |
Read pages and save the instance into database | def read_pages(self):
for file in os.listdir(self.repo_path):
if file.endswith('.md'):
if str(file) is not ('README.md' or '404.md'):
with open(self.repo_path + file, 'r') as page_file:
file_data = page_file.read()
c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, *args, **kwargs):\n created = False\n if self.pk is None:\n created = True\n super(Base, self).save(*args, **kwargs)\n if created is True:\n for i in range(self.page_count):\n page = Page(work=self, number=i+1)\n page.sa... | [
"0.6114496",
"0.60416394",
"0.59844977",
"0.59610665",
"0.5876366",
"0.5847255",
"0.57638466",
"0.5758273",
"0.57403046",
"0.57091016",
"0.5637539",
"0.5621401",
"0.55633825",
"0.5521344",
"0.5509448",
"0.55065763",
"0.5492751",
"0.54720575",
"0.5468598",
"0.54553676",
"0.540... | 0.6453269 | 0 |
read all files that we want at any time. we have to pass the extension and exception_list. exception_list will contain the list of all the files that should'nt be scanned. repo is the Repo db instance | def read_pages(self, repo, extension, exception_list):
for file in os.listdir(self.repo_path):
if file.endswith('.'.join(['', extension])):
if file not in exception_list:
file_handler = FileHandler(self.repo_path, file)
content = file_handler.r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_files_with_extension(self, extension=sys.argv[1]) -> list:\n if extension == \"\":\n raise EnvironmentError(\"No extension provided!\")\n\n result = []\n for idx, file in enumerate(self.file_list):\n if re.search(extension + \"$\", file):\n result.a... | [
"0.6206179",
"0.6107929",
"0.6043444",
"0.593927",
"0.58915067",
"0.58556247",
"0.57860583",
"0.57807255",
"0.5777453",
"0.5773534",
"0.5771638",
"0.57592523",
"0.57556206",
"0.5750356",
"0.5739557",
"0.57273585",
"0.57255244",
"0.57110775",
"0.5685773",
"0.56543374",
"0.5647... | 0.72571635 | 0 |
Start a daemon thread. | def kick_off(self):
if self.status == self.stage + "_script" + "_ready":
self.status = self.stage+"_running"
self._update_status()
p = Process(target=process_kick_off,
args=(self.setting,
self.script_dir,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _start_thread(self, fn, daemon=False):\n daemon = Thread(target=fn, daemon=daemon)\n daemon.start()",
"def start_daemon(self, *args, **kwargs):\n pass",
"def start(self) -> None:\n self.should_exit = False\n self._main_thread = threading.Thread(target=self._wrap_start, da... | [
"0.7886493",
"0.7687948",
"0.7490176",
"0.74892354",
"0.7463265",
"0.73720425",
"0.73632795",
"0.73606414",
"0.73606414",
"0.73606414",
"0.73606414",
"0.7244983",
"0.713184",
"0.7104449",
"0.7020524",
"0.6900436",
"0.6887967",
"0.6858836",
"0.67236525",
"0.6631534",
"0.661675... | 0.0 | -1 |
Update status to database | def _update_status(self):
self._db_update({'status': self.status}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateStatus(self, status):\n pass",
"def UpdateStatus(self, status):\r\n self.status.update(status)",
"def updatestatus(self):\n self.status = self.query()\n if self.status['success']:\n return True\n else:\n return False",
"def update_status(request_... | [
"0.8104977",
"0.7823668",
"0.7671553",
"0.74507135",
"0.7403075",
"0.73636246",
"0.72525454",
"0.725253",
"0.72357446",
"0.7171517",
"0.7166486",
"0.70517457",
"0.7043152",
"0.7029378",
"0.7019931",
"0.6978809",
"0.69682807",
"0.6892425",
"0.68785965",
"0.6876388",
"0.6852951... | 0.90569335 | 0 |
Process environment to run a job. | def process_kick_off(setting, script_dir, stage):
print("Info: run started for %s."%script_dir)
run_dir = setting['run_dir']
_id = setting['_id']
process = subprocess.Popen("/bin/bash %s"%(script_dir), shell=True)
process_pid = process.pid
db = db_connector()
db.run.update_one({'_id': _id},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_env(self, job, private_data_dir, private_data_files=None):\n env = super(RunJob, self).build_env(job, private_data_dir, private_data_files=private_data_files)\n if private_data_files is None:\n private_data_files = {}\n # Set environment variables needed for inventory and ... | [
"0.6484504",
"0.63290864",
"0.61382174",
"0.61110395",
"0.6017838",
"0.5864727",
"0.574876",
"0.56816065",
"0.56475335",
"0.56380653",
"0.56336087",
"0.5619758",
"0.5615859",
"0.56025904",
"0.5592658",
"0.55919296",
"0.559164",
"0.5563601",
"0.55622053",
"0.5527674",
"0.55165... | 0.0 | -1 |
A run step will contain 3 stage, and run_dir created in the train stage. | def _create_run_dir(self):
task_name = 'task_'+str(self.setting['task_id'])
run_name = '_'.join(['run',
str(self.setting['run_idx']),
str(self.setting['_id'])])
run_dir = op.join(Job_Requestor.run_center, task_name, run_name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_step(self):\n pass",
"def do_run(run, dirname, args):\n with tf.Graph().as_default():\n learner_assumptions = get_learner_assumption_kwargs(args)\n\n # Each run has a different random seed equal to the run id.\n np.random.seed(run)\n random.seed(run)\n\n is_... | [
"0.6543632",
"0.6523984",
"0.6473349",
"0.6370569",
"0.6366125",
"0.62685615",
"0.6171947",
"0.60079527",
"0.600611",
"0.59939355",
"0.5971192",
"0.5918415",
"0.5898618",
"0.58898205",
"0.5867497",
"0.5855395",
"0.5853683",
"0.58412033",
"0.58245564",
"0.5821443",
"0.5776301"... | 0.5966843 | 11 |
Function to generate distributed training scripts. | def generate_disttrain_scipts(self):
train_py = "/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py"
py = self.global_setting.get('python', sys.executable)
ex_options = self.global_setting.get('train_options', str())
if not os.access(py, os.X_OK):
py = "/home/haihua... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def script_generator(self):\n\n self._get_free_tcp_port()\n\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('train_options', str())\n\n if not os.access(py... | [
"0.7570193",
"0.724141",
"0.7049878",
"0.6241078",
"0.6189553",
"0.6151004",
"0.6111944",
"0.6034311",
"0.60096145",
"0.59790266",
"0.59271824",
"0.58651984",
"0.5852421",
"0.5842843",
"0.58210456",
"0.58143574",
"0.5811275",
"0.58090484",
"0.5808338",
"0.58027387",
"0.580093... | 0.7527086 | 1 |
Function to generate distributed training scripts. | def generate_singletrain_scipts(self):
py = self.global_setting.get('python', sys.executable)
ex_options = self.global_setting.get('train_options', str())
train_py = "/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py"
if not os.access(py, os.X_OK):
py = "/home/haih... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def script_generator(self):\n\n self._get_free_tcp_port()\n\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('train_options', str())\n\n if not os.access(py... | [
"0.7570193",
"0.7527086",
"0.724141",
"0.6241078",
"0.6189553",
"0.6151004",
"0.6111944",
"0.6034311",
"0.60096145",
"0.59790266",
"0.59271824",
"0.58651984",
"0.5852421",
"0.5842843",
"0.58210456",
"0.58143574",
"0.5811275",
"0.58090484",
"0.5808338",
"0.58027387",
"0.580093... | 0.7049878 | 3 |
Function to generate the scripts to analyze the log. | def script_generator(self):
analyze_tool = "/home/haihuam/Projects/RepPoints/mmdetection/tools/analyze_logs.py"
ex_options = self.global_setting.get('analyze_options', str())
py = self.global_setting.get('python', sys.executable)
if os.access(py, os.X_OK):
content = "set -e \... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def script_generator(self):\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('evaluate_options', str())\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n if os.access(py, os.X_OK):\n content = \"set -... | [
"0.6372324",
"0.6196502",
"0.58817005",
"0.5872832",
"0.5843183",
"0.57949096",
"0.5750669",
"0.5748845",
"0.57101727",
"0.56722856",
"0.5642168",
"0.56294507",
"0.5594446",
"0.55805284",
"0.552635",
"0.55260634",
"0.5525768",
"0.5515622",
"0.5510869",
"0.5489981",
"0.5473564... | 0.81086046 | 0 |
Function to generate distributed training scripts. | def script_generator(self):
self._get_free_tcp_port()
train_py = "/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py"
py = self.global_setting.get('python', sys.executable)
ex_options = self.global_setting.get('train_options', str())
if not os.access(py, os.X_OK):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_disttrain_scipts(self):\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('train_options', str())\n\n if not os.access(py, os.X_OK):\n py = ... | [
"0.7527086",
"0.724141",
"0.7049878",
"0.6241078",
"0.6189553",
"0.6151004",
"0.6111944",
"0.6034311",
"0.60096145",
"0.59790266",
"0.59271824",
"0.58651984",
"0.5852421",
"0.5842843",
"0.58210456",
"0.58143574",
"0.5811275",
"0.58090484",
"0.5808338",
"0.58027387",
"0.580093... | 0.7570193 | 0 |
Function to generate distributed training scripts. | def script_generator(self):
py = self.global_setting.get('python', sys.executable)
ex_options = self.global_setting.get('evaluate_options', str())
train_py = "/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py"
if os.access(py, os.X_OK):
content = "set -e \n"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def script_generator(self):\n\n self._get_free_tcp_port()\n\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('train_options', str())\n\n if not os.access(py... | [
"0.7570193",
"0.7527086",
"0.7049878",
"0.6241078",
"0.6189553",
"0.6151004",
"0.6111944",
"0.6034311",
"0.60096145",
"0.59790266",
"0.59271824",
"0.58651984",
"0.5852421",
"0.5842843",
"0.58210456",
"0.58143574",
"0.5811275",
"0.58090484",
"0.5808338",
"0.58027387",
"0.58009... | 0.724141 | 2 |
Login to retrieve a temporary Authorization token | def get(self, name, password):
if not Account(name).exists():
time.sleep(1)
api_v1.abort(401, "Bad credentials")
if Account(name).check(password):
access_token = create_access_token(identity=name)
return jsonify(access_token=access_token)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):\n r = self._login_token()",
"def _login_token(self):\n data = {\n 'cmd': 'login',\n 'login': self.username,\n 'password': self.password,\n }\n \n token = self.helper._post_request(\n self.basename,\n ... | [
"0.7765029",
"0.7436251",
"0.7297772",
"0.7242992",
"0.71246564",
"0.706187",
"0.70572585",
"0.7040267",
"0.70295143",
"0.69927466",
"0.69232893",
"0.6919958",
"0.69061095",
"0.6899295",
"0.68976974",
"0.68976974",
"0.689317",
"0.68893045",
"0.68805665",
"0.68671083",
"0.6860... | 0.0 | -1 |
Parses given yaml file using requirements and defaults. Required parameters are defined in this function along with parameter defaults. Parameters are grouped by package name. | def parse_config(file):
# dictionaries specifying required parameters for various modules
general = ["tube_number", "tube_radius", "collision_objects_filename"]
optimizers = {"nelder_mead": ["optimizer_precision", "optimize_iterations"]}
solvers = {"rrt": ["step_bound", "iteration_number",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_parameters(self):\n with open(INTERNAL_DATA_DIR / self.name_default_params, 'r') as f:\n return yaml.load(f, Loader=yaml.FullLoader)",
"def yamlConfigForParsingPlugins():\n parameters = \"\"\"\njoinPaths: !joinPaths\n - a\n - b\n - \"c\"\nrunPageTemplates: !findRunPageTempl... | [
"0.60205275",
"0.5976597",
"0.59591246",
"0.5929077",
"0.58939296",
"0.58272904",
"0.5821543",
"0.5787672",
"0.5710688",
"0.5634528",
"0.56288314",
"0.5624165",
"0.5618275",
"0.5608895",
"0.55601114",
"0.55350167",
"0.55314714",
"0.5524504",
"0.5521616",
"0.5514817",
"0.55096... | 0.548502 | 23 |
Validates and modifies the dictionary Checks tube number against given radii, max tube lengths, and given q_dof. Checks that the lengths are all divisible by delta_x and raises an error if not. | def config_validation(configuration):
tube_num = configuration.get('tube_number')
q_dof = configuration.get('q_dof')
radius = configuration.get('tube_radius')
delta_x = configuration.get('delta_x')
tube_lengths = configuration.get('tube_lengths')
if isinstance(q_dof, int):
configuration... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self):\n # check for nonsense or missing mandatory parameters\n mdp = self.parameters.get( \"md\", [] )\n fp = self.parameters.get( \"files\", [] )\n ip = self.parameters.get( \"intervals\", [] )\n\n for keyword in (\"temperature\", \"steps\", \"stepsize\"):\n ... | [
"0.52189726",
"0.5177317",
"0.5169023",
"0.51312196",
"0.5052218",
"0.50168866",
"0.4954876",
"0.48952448",
"0.4873793",
"0.4869507",
"0.48316526",
"0.48261344",
"0.4816464",
"0.47993284",
"0.4798235",
"0.47845814",
"0.47829345",
"0.47609234",
"0.47100845",
"0.46791354",
"0.4... | 0.6384456 | 0 |
Helper function that sets parameters for given package type. Gets the list of required parameters for the module specified by the config_key entry in the config. Adds these parameters to the config, if they exist; if not, sets to the default values with a printed message detailing the omission. | def _config_helper(config_key, required_dict, config, filename, defaults):
this_type = config.get(config_key)
if this_type not in required_dict:
config[config_key] = defaults.get(config_key)
print(f"{config_key} {this_type} does not exist. Using default of "
f"{defaults.get(config_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_config_required(self, key: str, type_):\n\n self.config_required[key] = type_",
"def update_config(self, config):\n self.config = {\n \"display_name\": \"\",\n \"description\": \"\",\n \"required\": 1,\n \"type\": \"string\"\n }\n ... | [
"0.5927595",
"0.543951",
"0.543951",
"0.5400199",
"0.53748196",
"0.53700477",
"0.5367941",
"0.53294605",
"0.53097403",
"0.5300128",
"0.5266753",
"0.52600294",
"0.52449757",
"0.5216351",
"0.52057993",
"0.5176022",
"0.51694614",
"0.51691985",
"0.51570326",
"0.5136258",
"0.51111... | 0.53431654 | 7 |
code_ranges is a list of lists | def icd9_in_code_range(val, code_ranges):
return any(val <= code_range[1] and val >= code_range[0] for code_range in code_ranges) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_ranges():",
"def summarize_ranges(self, ranges):\n if len(ranges) == 0: return []\n min_ = 'min'\n max_ = 'max'\n for r in ranges:\n if r[0][0] == \"min\":\n r[0][0] = min_\n else:\n min_ = r[0][0]\n if r[-1][1] ... | [
"0.68527627",
"0.6253134",
"0.6252875",
"0.61829406",
"0.61572516",
"0.61479306",
"0.612069",
"0.6090808",
"0.60688955",
"0.60551345",
"0.60524595",
"0.5867531",
"0.58523124",
"0.58206266",
"0.5810372",
"0.5810281",
"0.5805071",
"0.5775448",
"0.57740957",
"0.57708406",
"0.576... | 0.60457057 | 11 |
Takes an object and returns a list of names of all the methods in that class | def classmethods(class_object):
fn_tuple_list = inspect.getmembers(class_object, predicate=inspect.ismethod)
fn_names = [
f_name for (f_name, method) in fn_tuple_list if not f_name.startswith("_")
]
return fn_names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def methods_of(obj):\r\n result = []\r\n for i in dir(obj):\r\n if callable(getattr(obj, i)) and not i.startswith('_'):\r\n result.append((i, getattr(obj, i)))\r\n return result",
"def lookup(obj):\n objList = [method_name for method_name in dir(obj)\n if callable(geta... | [
"0.81180924",
"0.77584505",
"0.7427535",
"0.7369807",
"0.7367492",
"0.7268082",
"0.7225354",
"0.70353705",
"0.70313483",
"0.70313483",
"0.7011768",
"0.6934401",
"0.6904447",
"0.68782264",
"0.68726104",
"0.6863157",
"0.6825215",
"0.6760233",
"0.67479444",
"0.67468894",
"0.6688... | 0.8122183 | 0 |
Takes a function as parameter and returns a list of argument names | def argnames(method):
return [arg for arg in method.__code__.co_varnames if arg != "self"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def arguments_from_funccode(f):\n fc = fc_or_c(f)\n vnames = fc.co_varnames\n nargs = fc.co_argcount\n # bound method and fake function will be None\n args = vnames[1 if is_bound(f) else 0:nargs]\n if not args:\n raise RuntimeError('Function has variable number of arguments')\n return l... | [
"0.7419391",
"0.7338321",
"0.70527124",
"0.6997746",
"0.6993407",
"0.69520026",
"0.6950231",
"0.6946659",
"0.68849266",
"0.6846403",
"0.6641554",
"0.6599002",
"0.6593807",
"0.6548676",
"0.6548385",
"0.6535864",
"0.65309715",
"0.65237266",
"0.6499961",
"0.6365761",
"0.63627267... | 0.7037488 | 3 |
Returns name of class of an instance as a str | def classname(class_object):
return class_object.__class__.__name__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def instance_class_name(instance):\n return class_name(instance.__class__)",
"def instance_class_name(instance):\n return class_name(instance.__class__)",
"def getclassname(instance_or_cls):\n return getclass(instance_or_cls).__name__",
"def className(self):\n namevalue = self.__class__.__nam... | [
"0.8504247",
"0.8504247",
"0.83157873",
"0.8211755",
"0.8108531",
"0.8108531",
"0.8054307",
"0.7942855",
"0.7918502",
"0.7893028",
"0.7857822",
"0.7854775",
"0.77941525",
"0.7652028",
"0.75155056",
"0.75007874",
"0.7458795",
"0.74195534",
"0.74195534",
"0.7388337",
"0.7353441... | 0.76834095 | 13 |
Train the model with a given training set. | def train(self, training_set, missing_residues=None, use_aic=False):
if not self.show_warnings:
warning_list = warnings.filters[:]
warnings.filterwarnings('ignore', category=TorusDBNWarning)
if missing_residues is not None:
missing_residues = read_missing... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, training_set):\n self.originModel.train(training_set)\n return self",
"def train(self, training_set):\n\n lengths = [ seq.shape[0] for seq in training_set ]\n\n #preprocessing the training set to obtain the desired shape\n concatenated_set = self.preprocessing(... | [
"0.8236125",
"0.810741",
"0.80620813",
"0.7919706",
"0.7710924",
"0.7675048",
"0.7651888",
"0.76291656",
"0.7588788",
"0.75395983",
"0.75060767",
"0.7495371",
"0.74554676",
"0.7392441",
"0.7390008",
"0.73750174",
"0.73489285",
"0.73284245",
"0.731839",
"0.7304062",
"0.7304062... | 0.0 | -1 |
The Akaike information criterion (AIC) is a measure of the relative goodness of fit of a statistical model. Akaike, Hirotugu (1974). "A new look at the statistical model | def calculate_AIC(self):
hmm_ll_calculator = LikelihoodInfEngineHMM(
dbn=self.model.dbn, hidden_node_index=0, check_dbn=False)
ll_full = hmm_ll_calculator.calc_ll(self.seq_list, self.mismask_list)
return 2 * ll_full - 2 * self._get_parameter_count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_aic_ms(distribution):\n print(\"TESTING: AIC model selection for %s distribution\" % distribution.upper())\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\n print(\" creating sample\")\n test_sample = dist.samples(distribution, params)\n print(\" calculating AIC for all ... | [
"0.7080638",
"0.67313176",
"0.66234607",
"0.6486055",
"0.61601174",
"0.6079734",
"0.6033591",
"0.57279545",
"0.57276684",
"0.563323",
"0.56095815",
"0.555238",
"0.5534736",
"0.5459357",
"0.5456556",
"0.54511565",
"0.5418131",
"0.5415451",
"0.5370663",
"0.5346118",
"0.5329103"... | 0.6961269 | 1 |
The Bayesian information criterion (BIC) is a criterion for model selection among a finite set of models. Schwarz, Gideon E. (1978). "Estimating the dimension of a model". Annals | def calculate_BIC(self):
hmm_ll_calculator = LikelihoodInfEngineHMM(
dbn=self.model.dbn, hidden_node_index=0, check_dbn=False)
ll_full = hmm_ll_calculator.calc_ll(self.seq_list, self.mismask_list)
return 2 * ll_full - self._get_parameter_count() * math.log(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bic_ms(distribution):\n print(\"TESTING: BIC model selection for %s distribution\" % distribution.upper())\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\n print(\" creating sample\")\n test_sample = dist.samples(distribution, params)\n print(\" calculating BIC for all ... | [
"0.6738231",
"0.6541316",
"0.6489599",
"0.63965064",
"0.6255589",
"0.61559856",
"0.6112755",
"0.6090768",
"0.59615993",
"0.59547305",
"0.59203905",
"0.59203905",
"0.58714235",
"0.5793341",
"0.5740092",
"0.57190186",
"0.56444794",
"0.5625056",
"0.5620049",
"0.5608862",
"0.5584... | 0.68793404 | 0 |
Check whether likelihood is oscilating during the training. | def __get_hairiness(self, ll_list):
for j in xrange(self.convergence_window, len(ll_list)):
match=0
for i in xrange(self.convergence_window):
# Test if likelihood is oscillating
if (ll_list[j-i] > ll_list[j-i+1] and ll_list[j-i] > ll_list[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_artificial(self):\n\t\treturn 0",
"def sanity_check(self):\n res = True\n res = res and self.detected\n res = res and np.sum(self.diffs) < 30000 # experimental value\n return res",
"def accept_move(misfit_current, likelihood_current, misfit_proposednext):\n if misfit_prop... | [
"0.6125425",
"0.6125098",
"0.6034057",
"0.5971424",
"0.59698826",
"0.59594226",
"0.59022266",
"0.5869513",
"0.58606696",
"0.5846239",
"0.5841704",
"0.5766215",
"0.57316715",
"0.57314795",
"0.57080024",
"0.57065547",
"0.5668403",
"0.5638142",
"0.5593511",
"0.5579463",
"0.55629... | 0.5925486 | 6 |
Create sequence and mismask (mask that identifies values as hidden, observed or missing) from a training set. | def _create_sequence_and_mismask(self, training_set, missing_residues):
seq_list = []
mismask_list = []
if not self.show_warnings:
warning_list = warnings.filters[:]
warnings.filterwarnings('ignore', category=TorusDBNWarning)
training_set_cou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_masked_targets(self, item_ids: tf.Tensor, training: bool = False) -> MaskingInfo:\n\n labels = tf.cast(tf.fill(item_ids.shape, self.padding_idx), dtype=item_ids.dtype)\n non_padded_mask = tf.cast(item_ids != self.padding_idx, labels.dtype)\n rows_ids = tf.range(labels.shape[0], dt... | [
"0.62820804",
"0.60834235",
"0.5759483",
"0.57154673",
"0.56921595",
"0.5655835",
"0.56276035",
"0.5595453",
"0.55943155",
"0.55873364",
"0.55382186",
"0.5523225",
"0.54959726",
"0.5485287",
"0.54780704",
"0.54613227",
"0.5454266",
"0.5439734",
"0.5433462",
"0.5433462",
"0.54... | 0.6283801 | 0 |
Optimization method to find the best size for the hidden node according to a training set. | def find_optimal_model(
self, training_set, use_aic=False, min_node=10,
max_node=90, start_size=20, end_size=5, node_samples=4,
check_decreasing_ll=False, missing_residues=None):
if not self.show_warnings:
warning_list = warnings.filters[:]
warnings.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hidden_layer_size(self):\r\n return self.hidden_layer_size",
"def get_num_hidden(self) -> int:\n return self.config.model_size",
"def get_n_best(self):\n pass",
"def get_final_emb_size(self):\n size = self.n_layers * 1 * 2 * self.hidden_size\n return size",
... | [
"0.5985635",
"0.5964452",
"0.593218",
"0.58241916",
"0.58158845",
"0.58039904",
"0.5761179",
"0.5725219",
"0.5707045",
"0.5702115",
"0.5667222",
"0.56550604",
"0.5606332",
"0.5548744",
"0.5548744",
"0.5546417",
"0.55433387",
"0.5542178",
"0.5492614",
"0.5483099",
"0.5469575",... | 0.6054712 | 0 |
Print a message to the standard output, in case show_info is enabled. | def info(self, message):
if self.show_info:
print(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_info(msg):\n print(msg)",
"def show_info(title, message):\n\n pass",
"def print_info(message: str):\n global verbose\n if verbose:\n print(\"%s%s%s\" % (KYEL, message, KNRM))",
"def info(msg, *args):\n if args:\n msg %= args\n click.echo(msg, file=sys.stdout)",
"de... | [
"0.78605205",
"0.7734865",
"0.76229465",
"0.7563187",
"0.7400993",
"0.73952097",
"0.7378441",
"0.7370511",
"0.7139444",
"0.7125532",
"0.7115362",
"0.71005535",
"0.7092673",
"0.70315975",
"0.70026535",
"0.6999533",
"0.69383913",
"0.69325316",
"0.6913429",
"0.6901743",
"0.68721... | 0.83142126 | 0 |
Get the current TorusDBN model. | def get_model(self):
return self.model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_model(self):\n # just return the first model, since all replicas are the same\n return self.call_async(0, '_async_get_model').gen()",
"def get_model(self):\n return self.model.module if isinstance(self.model, DDP) else self.model",
"def get_model(self):\n return self._model"... | [
"0.7258813",
"0.72392356",
"0.70535207",
"0.70535207",
"0.701487",
"0.69739246",
"0.6939528",
"0.69378126",
"0.69378126",
"0.69378126",
"0.69378126",
"0.69378126",
"0.693138",
"0.6896313",
"0.688577",
"0.6831938",
"0.6797406",
"0.677369",
"0.67602867",
"0.6741396",
"0.6736469... | 0.7090027 | 11 |
The total number of observations. | def _get_observation_count(self):
observation_count = 0
for sequence in self.seq_list:
observation_count += sequence.shape[0]
return observation_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTotalIndividualCount(self):\r\n return self._n",
"def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ... | [
"0.7855842",
"0.7715139",
"0.76306987",
"0.7599567",
"0.757905",
"0.74909234",
"0.7462525",
"0.74385345",
"0.74164623",
"0.73858225",
"0.73710364",
"0.73710364",
"0.73710364",
"0.7346027",
"0.73373866",
"0.7333386",
"0.7324687",
"0.73124564",
"0.72969145",
"0.7296742",
"0.726... | 0.7648131 | 2 |
The number of parameters. | def _get_parameter_count(self):
parameters_d = 5;
size_h = self.model.size_h
return (size_h - 1) + size_h * (
(size_h - 1) + parameters_d + (self.model.size_aa - 1) +
(self.model.size_ss - 1) + (self.model.size_cis - 1)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_params(self):",
"def number_of_parameters(self):\n return len(self.parameters)",
"def _n_parameters(self):\n raise NotImplementedError",
"def num_parameters(self) -> int:\n return len(self) * self.convention.value",
"def get_num_parameters(self):\n return len(self.parame... | [
"0.90070146",
"0.89986014",
"0.89931357",
"0.8770135",
"0.8762096",
"0.867157",
"0.866098",
"0.8596319",
"0.85476184",
"0.85042757",
"0.8387441",
"0.83733743",
"0.83527464",
"0.8283258",
"0.8156946",
"0.81524104",
"0.8139067",
"0.80919164",
"0.8061227",
"0.8043313",
"0.804074... | 0.77220786 | 28 |
Does the url contain a downloadable resource | def is_downloadable(url):
h = requests.head(url, allow_redirects=True)
header = h.headers
content_type = header.get('content-type')
if 'text' in content_type.lower():
return False
if 'html' in content_type.lower():
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_downloadable(url) -> bool:\n content_type = requests.head(url, allow_redirects=True).headers.get('content-type')\n if 'text' in content_type.lower() or 'html' in content_type.lower():\n return False\n return True",
"def is_downloadable(self):\n return True",
"def is_downloadable(s... | [
"0.7863911",
"0.76044476",
"0.75145316",
"0.74376166",
"0.736647",
"0.7229701",
"0.71826774",
"0.7152465",
"0.71362215",
"0.70722294",
"0.7068388",
"0.70574546",
"0.7050864",
"0.6838795",
"0.6838795",
"0.6756243",
"0.67460054",
"0.66819596",
"0.66469514",
"0.6644246",
"0.6609... | 0.7924052 | 0 |
Go to the given workspace number. | def go_to(i3: i3ipc.Connection, workspace: int):
i3.command(f"workspace number {workspace}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_workspace(num):\n LOGGER.debug('change_workspace: requested workspace {}'.format(num))\n output = get_focused_output()\n prefix = get_workspace_prefix(output)\n ws_num = get_workspace_num(prefix, num)\n workspace = get_workspace(ws_num, prefix, num)\n result = switch_workspace(f'{works... | [
"0.71325797",
"0.6187763",
"0.6157023",
"0.59943575",
"0.5943539",
"0.5912566",
"0.58262795",
"0.57753295",
"0.5770139",
"0.55275774",
"0.5519753",
"0.5467741",
"0.54426324",
"0.5431287",
"0.5407863",
"0.5407681",
"0.5323033",
"0.5264269",
"0.5262899",
"0.5244698",
"0.5241639... | 0.79520303 | 0 |
Move the focused container to the given workspace. | def move_to(i3: i3ipc.Connection, workspace: int):
i3.command(f"move container to workspace number {workspace}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_container(i3, name, monitor, container_id=None):\n i3.command(f'move container to workspace {name}')\n i3.command(f'workspace {name}, move workspace to output {monitor}')\n if container_id:\n i3.command(f'[con_id=\"{container_id}\"] focus')",
"def set_workspace(client, workspace):\n d... | [
"0.72039133",
"0.56448215",
"0.55889195",
"0.5587443",
"0.5435935",
"0.5378369",
"0.5328443",
"0.52069813",
"0.5197307",
"0.51802254",
"0.50865215",
"0.50180376",
"0.50041604",
"0.49425906",
"0.48882422",
"0.48878294",
"0.4881337",
"0.48195142",
"0.4800425",
"0.4756636",
"0.4... | 0.73667777 | 0 |
Find the workspace to switch to. If the current workspace is a target, go to the next target. If the current workspace isn't a target, go to the first open target. | def get_target_workspace(current_workspace, open_workspaces, target_workspaces):
logger.debug('get_target_workspace(current: %s, open: %s, targets: %s)',
current_workspace, open_workspaces, target_workspaces)
if len(target_workspaces) <= 0:
logger.debug('No workspaces given - defaultin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def go_to(i3: i3ipc.Connection, workspace: int):\n i3.command(f\"workspace number {workspace}\")",
"def next_workspace(self, flag='next'):\n non_visible_workspaces = filter(lambda w: not w['visible'],\n self.get_workspaces())\n\n if non_visible_workspaces =... | [
"0.60954845",
"0.58509964",
"0.5680681",
"0.56290454",
"0.54656833",
"0.53953046",
"0.5384196",
"0.53578043",
"0.529885",
"0.5252498",
"0.520959",
"0.52038735",
"0.51325685",
"0.50813437",
"0.50762445",
"0.5061682",
"0.50541234",
"0.5039189",
"0.50001895",
"0.49859533",
"0.49... | 0.73417485 | 0 |
Get the number of the current workspace. | def get_current_workspace_num(i3: i3ipc.Connection):
return i3.get_tree().find_focused().workspace().num | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def workspace_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"workspace_id\")",
"def workspace_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"workspace_id\")",
"def workspace_id(self) -> str:\n return pulumi.get(self, \"workspace_id\")",
"def workspace_id(self) -... | [
"0.70615363",
"0.70615363",
"0.70028317",
"0.70028317",
"0.68003416",
"0.6721158",
"0.67083037",
"0.6684436",
"0.6620677",
"0.6572125",
"0.6547534",
"0.6448233",
"0.6448233",
"0.6275984",
"0.6210025",
"0.616503",
"0.6121598",
"0.6117455",
"0.6078367",
"0.6078367",
"0.6078367"... | 0.81946534 | 0 |
Get the numbers of open workspaces. | def get_open_workspaces(i3: i3ipc.Connection):
return [ws.num for ws in i3.get_tree().workspaces()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_opened_windows_list():\n\n global opened_windows_names\n EnumWindows(EnumWindowsProc(foreach_window), 0)\n return opened_windows_names",
"def get_open_disk_space(self):\n count = 0\n for i in range(self.size):\n if self.disk_mem[i]==\".\":\n count += 1\n ... | [
"0.64218664",
"0.63412476",
"0.61509293",
"0.6022424",
"0.60122925",
"0.5947481",
"0.5943279",
"0.5939426",
"0.59035146",
"0.58829737",
"0.5813977",
"0.57102287",
"0.56623214",
"0.56597006",
"0.5650875",
"0.5648794",
"0.56483734",
"0.5648095",
"0.5639259",
"0.5620538",
"0.561... | 0.7764141 | 0 |
We mock the call to ActivityStream | def test_search_view(client):
with patch('search.helpers.search_with_activitystream') as search:
mock_results = json.dumps(
{
'took': 17,
'timed_out': False,
'_shards': {'total': 4, 'successful': 4, 'skipped': 0, 'failed': 0},
'hit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_activity(self):\n pass",
"def test_get_activity(self):\n pass",
"def test_get_stream(self):\n pass",
"def test_stream_publish(self):\n pass",
"def test_meeting_live_stream_update(self):\n pass",
"def test_workflows_change_stream_get(self):\n pass",
... | [
"0.6981633",
"0.6981633",
"0.69358",
"0.673582",
"0.6572297",
"0.6561777",
"0.65350914",
"0.65160114",
"0.63600963",
"0.63600963",
"0.63470894",
"0.63404083",
"0.62458944",
"0.6218481",
"0.6211634",
"0.6186519",
"0.6151537",
"0.6102448",
"0.60806936",
"0.59994423",
"0.5920417... | 0.5863266 | 23 |
Provides an ndimensional parallel iterator that generates index tuples for each iteration point. Sequentially, pndindex is identical to np.ndindex. | def pndindex(*args):
return np.ndindex(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pndindex(*args):\n return np.ndindex(*args)",
"def master_ndindex(self): # itermaster_indices(self):\n return itertools_product(\n *[range(*r) for r in self.location]\n ) # TODO check",
"def _get_index_iterator(indexes, length):\n return combinations(indexes, length)",
... | [
"0.698849",
"0.67596734",
"0.6384372",
"0.6358893",
"0.6060668",
"0.5980556",
"0.59671396",
"0.59533405",
"0.58904546",
"0.583905",
"0.57712317",
"0.57544845",
"0.57544845",
"0.57114184",
"0.56809837",
"0.5676592",
"0.5672165",
"0.5670588",
"0.5669132",
"0.5669132",
"0.563339... | 0.69749606 | 1 |
Initializes a new ``StreamingHandler`` | def __init__(
self,
stream: TextIOWrapper,
name: Optional[str] = None,
level: Optional[LogLevel] = None,
):
self.stream: TextIOWrapper = stream
super().__init__(name=name, level=level) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_stream_handler(\n self, \n logger, \n loop, \n netconf_ip, \n netconf_port,\n statistics,\n xml_to_json_translator):\n self._logger = logger\n self._asyncio_loop = loop\n self._encoding = \"xml\"\n sel... | [
"0.7229474",
"0.6860277",
"0.66557497",
"0.66515875",
"0.66515875",
"0.66443104",
"0.660984",
"0.6570745",
"0.64102125",
"0.638577",
"0.63654643",
"0.6354286",
"0.6353217",
"0.63436896",
"0.6324287",
"0.6289065",
"0.6260624",
"0.62495697",
"0.62406313",
"0.623029",
"0.623029"... | 0.5809078 | 53 |
Writes the full log entry to a configured stream | def write(self, message: str, level: LogLevel) -> None:
if level >= self.min_level:
self.stream.write(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _writeLog (self, item):\n self.log.write (item.encode (self.logEncoding))\n self.log.write (b'\\n')\n # instead of locking, check we’re running in the main thread\n if self.log.tell () > self.maxLogSize and \\\n threading.current_thread () is threading.main_thread ():... | [
"0.65572536",
"0.64755356",
"0.6350549",
"0.6347381",
"0.6335092",
"0.6318135",
"0.62677616",
"0.62644315",
"0.6250166",
"0.6086238",
"0.60699415",
"0.60698074",
"0.6056047",
"0.60518456",
"0.6018502",
"0.60063845",
"0.5952854",
"0.59488386",
"0.5948345",
"0.594813",
"0.59023... | 0.0 | -1 |
Creates the name for the handler called from ``__init__`` if a name is not given. | def _create_name(self) -> str:
return self.stream.__class__.__name__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __set_name__(self, cls, name):\n pass",
"def _get_name(cls, **kwargs: Any) -> str:\n raise NotImplementedError('Subclasses must implement this method.') # pragma: no cover",
"def __init__(__self__, *,\n name: pulumi.Input[str]):\n pulumi.set(__self__, \"name\", name)",... | [
"0.62612844",
"0.61916685",
"0.6182883",
"0.61657673",
"0.6151574",
"0.61496806",
"0.6144922",
"0.61412007",
"0.61395377",
"0.61388636",
"0.61388636",
"0.61388636",
"0.61388636",
"0.61388636",
"0.61388636",
"0.6127988",
"0.6106006",
"0.60805684",
"0.60805684",
"0.60805684",
"... | 0.6380641 | 0 |
Initializes a new ``StdOutHandler`` | def __init__(
self, name: Optional[str] = "stdout", level: Optional[LogLevel] = None
):
super().__init__(name=name, level=level, stream=stdout) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, UI, strm=None):\n logging.Handler.__init__(self)\n # replace Handler's instance-specific lock with the shared class lock\n # to ensure that only one instance of this handler can write to\n # the console at a time\n self.lock = TerminalHandler.sharedlock\n ... | [
"0.7315729",
"0.6732507",
"0.66628474",
"0.6601927",
"0.64137137",
"0.63443863",
"0.6217379",
"0.61049914",
"0.60902756",
"0.5937705",
"0.5926769",
"0.5925762",
"0.5896303",
"0.5818868",
"0.5801836",
"0.5721819",
"0.57171315",
"0.5713157",
"0.5690763",
"0.56885356",
"0.568552... | 0.5459419 | 30 |
Initializes a new ``StdErrHandler`` | def __init__(
self, name: Optional[str] = "stderr", level: Optional[LogLevel] = None
):
super().__init__(name=name, level=level, stream=stderr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, UI, strm=None):\n logging.Handler.__init__(self)\n # replace Handler's instance-specific lock with the shared class lock\n # to ensure that only one instance of this handler can write to\n # the console at a time\n self.lock = TerminalHandler.sharedlock\n ... | [
"0.67312557",
"0.61103314",
"0.57938576",
"0.5744193",
"0.5707165",
"0.5694952",
"0.56396174",
"0.56094813",
"0.55404145",
"0.5531009",
"0.55161536",
"0.54900914",
"0.54808664",
"0.5460166",
"0.5435066",
"0.54107255",
"0.5393115",
"0.53788733",
"0.53571993",
"0.5352271",
"0.5... | 0.5435048 | 15 |
Attempts to cache `objdoc` for module `modname`. | def __setitem__(self, modname: str, objdoc: Objdoc):
spec = importlib.util.find_spec(modname)
if spec.origin is None:
raise CannotCache(f"not a module file; can't cache: {modname}")
path = self.__get_path(spec)
path = path.parent / (path.name + ".json.gz")
check = _g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __put_module_in_sys_cache(module_name, module_obj):\n #try:\n #if hasattr(sys, 'stypy_module_cache'):\n sys.stypy_module_cache[module_name] = module_obj\n # else:\n # __preload_sys_module_cache()\n # sys.stypy_module_cache[module_name] = module_obj\n # except:\n ... | [
"0.636846",
"0.60199344",
"0.5941785",
"0.5705336",
"0.56785536",
"0.56135726",
"0.5584943",
"0.54140854",
"0.53702223",
"0.5348207",
"0.5324705",
"0.52313477",
"0.51907396",
"0.51213115",
"0.50879973",
"0.5077939",
"0.5061241",
"0.50270915",
"0.49785343",
"0.49644643",
"0.49... | 0.66609263 | 0 |
True if `path` is a subpath of `other`. | def is_subpath(path: Path, other: Path):
try:
Path(path).relative_to(other)
except ValueError:
return False
else:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_sub(parent, path):\n parent = canonical_path(parent, resolve_link=False)\n path = canonical_path(path, resolve_link=False)\n return os.path.commonprefix([parent, path]) == parent",
"def _issubpath(self, a, b):\n p1 = a.rstrip(os.sep).split(os.sep)\n p2 = b.rstrip(os.sep).split(os.se... | [
"0.73897827",
"0.7339206",
"0.67567295",
"0.65496707",
"0.6387099",
"0.6286626",
"0.61776984",
"0.61434525",
"0.61350846",
"0.61014986",
"0.60929364",
"0.6068817",
"0.60278535",
"0.5977593",
"0.59686697",
"0.59164315",
"0.58905256",
"0.58664703",
"0.58248734",
"0.58200943",
"... | 0.8505086 | 0 |
Returns the path to the objdoc cache for a module. | def _get_pycache_path(spec: ModuleSpec) -> Path:
# Refuse to do __pycache__ caching for anything in PREFIX.
# FIXME: Not sure if this is the right policy.
if is_subpath(spec.origin, sys.prefix):
raise CannotCache(spec.name)
# Find out where the module cache file goes.
mod_cache_path = impor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cache_path(self):",
"def get_cache_path(self):",
"def cache_path(self):",
"def cache_path(self):",
"def cachepath(self, *args, **kw):\n cachename = self.cachefunc(*args, **kw)\n ret = os.path.join(self.cachedir, cachename)+'.'+self.serializer\n return ret",
"def get_module_pa... | [
"0.6733192",
"0.6733192",
"0.65243727",
"0.65243727",
"0.6192765",
"0.6134021",
"0.6128572",
"0.6034457",
"0.59029865",
"0.58758134",
"0.584348",
"0.583628",
"0.5831629",
"0.5797197",
"0.57850033",
"0.5753407",
"0.57359135",
"0.56733376",
"0.56616026",
"0.5656423",
"0.5656423... | 0.71900195 | 0 |
Returns the path to the supdoc cache directory. | def get_cache_dir() -> Path:
try:
cache_dir = Path(os.environ["SUPDOC_CACHE_DIR"])
except KeyError:
try:
cache_dir = Path(os.environ["XDG_CACHE_DIR"])
except KeyError:
if sys.platform == "linux":
cache_dir = Path.home() / ".cache"
elif ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_path(self):\n cache_path = os.path.join(os.path.dirname(__file__), '..', 'cache')\n if not os.path.exists(cache_path):\n os.mkdir(cache_path)\n return cache_path",
"def cache_path(self):",
"def cache_path(self):",
"def get_cache_path(self):",
"def get_cache_path(se... | [
"0.8008654",
"0.77709967",
"0.77709967",
"0.7667538",
"0.7667538",
"0.7616764",
"0.75312096",
"0.75106233",
"0.74233025",
"0.7411959",
"0.73736256",
"0.7335555",
"0.7317151",
"0.7300587",
"0.7297673",
"0.7265668",
"0.7265422",
"0.7102412",
"0.7053087",
"0.7030431",
"0.6959811... | 0.81167746 | 0 |
Returns a cache that stores files in a separate directory. | def DirCache(dir: Path) -> Cache:
dir = Path(dir)
return Cache(lambda spec: dir / spec.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cachefile(filename):\n if not os.path.exists(cachedir):\n os.makedirs(cachedir)\n return os.path.join(cachedir, filename)",
"def cache_file(cache_key):\n\n return MASTOOLS_DIR / f\"{cache_key}_cache.json\"",
"def cache_path(self):",
"def cache_path(self):",
"def cache(*filepath):\n ... | [
"0.7048509",
"0.6932892",
"0.69263685",
"0.69263685",
"0.6910586",
"0.68598944",
"0.68423784",
"0.6811715",
"0.67268217",
"0.67268217",
"0.66995484",
"0.6692884",
"0.66060275",
"0.6589656",
"0.65850544",
"0.6582661",
"0.6568272",
"0.6557517",
"0.6557517",
"0.6490931",
"0.6454... | 0.7716556 | 0 |
Caches modules in `modnames` and their submodules. | def cache_modules(*modnames) -> None:
inspector = Inspector()
modnames = { n for m in modnames for n in find_submodules(m) }
for modname in modnames:
logging.debug(f"inspecting: {modname}")
objdoc = inspector.inspect_module(modname)
logging.debug(f"writing cache: {modname}")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pymod_cache():\n pymod.cache.cache = Singleton(pymod.cache.factory)",
"def _refresh_cache():\n global _num_types, _num_funcs\n\n num_types = interrogate_number_of_global_types()\n num_funcs = interrogate_number_of_functions()\n\n if num_types != _num_types:\n for i in range(num_types):\... | [
"0.65368474",
"0.647988",
"0.60674167",
"0.6010362",
"0.5922582",
"0.5811887",
"0.5756406",
"0.57526934",
"0.5709762",
"0.5666927",
"0.5654441",
"0.5649179",
"0.5631578",
"0.5589954",
"0.5557051",
"0.5550639",
"0.5539117",
"0.54829466",
"0.5482664",
"0.5446342",
"0.5420631",
... | 0.82407486 | 0 |
Create a driver to the specified appium server & return driver,touch objects. | def create_driver(self, app_server):
config = self.config[app_server]
cmd = config['CMD']
server_name = config['NAME']
log_file_name = config['LOG_FILE_NAME']
full_log_path = os.path.join(os.environ['basedir'], 'logs', 'appium', log_file_name)
url = config['URL']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def appium_init(self):\n desired_cups = {}\n desired_cups['platformName'] = 'Android'\n desired_cups['platformVersion'] = android_version\n desired_cups['deviceName'] = device_name\n desired_cups['appPackage'] = pkg_name\n desired_cups['appActivity'] = activity\n de... | [
"0.6603057",
"0.6471961",
"0.6052382",
"0.6052382",
"0.6046912",
"0.5883527",
"0.5859736",
"0.5768993",
"0.56850535",
"0.55772156",
"0.54033375",
"0.5355655",
"0.5336413",
"0.52726877",
"0.5258186",
"0.5250311",
"0.52132326",
"0.5192618",
"0.5192618",
"0.51881385",
"0.5179297... | 0.7865572 | 0 |
Close the application, quits the drivers. | def close_driver(self):
package_dict = self.config['PACKAGE']
try:
self.driver.terminate_app(package_dict[self.app_name]) # Kill app
self.driver.quit() # Kill drivers
except WebDriverException:
pass
finally:
LOGGER.info("Closed {apl} on {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quit(self):\n self.driver.close_app()\n self.driver.quit()",
"def close_application(self):\n self.close()\n QtGui.QApplication.exit()",
"def close(self):\n\n self._driver.quit()",
"def program_close():\n\n print(\"\\n\")\n sys.exit(0)",
"def close(self):\n\n ... | [
"0.75867534",
"0.7412425",
"0.73730874",
"0.73533124",
"0.72978216",
"0.7290101",
"0.71743464",
"0.7127176",
"0.71195775",
"0.7048997",
"0.7048084",
"0.6993627",
"0.69605225",
"0.69441557",
"0.69411415",
"0.6929923",
"0.6924687",
"0.69232714",
"0.69213384",
"0.69039327",
"0.6... | 0.7819079 | 0 |
Read mobile window size & sets the scroll length for a mobile. | def set_scroll_length(self):
size = self.driver.get_window_size()
self.x_cord = int(size['width'] / 2)
self.start_y = int(size['height'] * 0.9)
self.end_y = int(size['height'] * 0.1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GetViewportSize(self):\n return self.tab.EvaluateJavaScript(\n '[ window.innerWidth, window.innerHeight ]')",
"def get_window_size():\n global windowSize\n windowSize = DRIVER.driver.get_window_size()\n return windowSize",
"def set_viewport_size(driver, device):\n if device == \"lapt... | [
"0.5914855",
"0.5613949",
"0.5598261",
"0.5566157",
"0.55612123",
"0.5541413",
"0.5541",
"0.5487701",
"0.5459118",
"0.5452546",
"0.5340624",
"0.5302332",
"0.524592",
"0.51727504",
"0.51644754",
"0.5149017",
"0.51306283",
"0.50865525",
"0.5083901",
"0.5060446",
"0.50539947",
... | 0.65684086 | 0 |
Perform tap for requested element or coordinates. | def tap_screen(self, element=None, config=None, x_cord=None, y_cord=None):
if element and config:
self.touch.tap(x=config[element]['x'],
y=config[element]['y']).perform()
elif x_cord:
self.touch.tap(x=x_cord, y=y_cord).perform()
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tap(self, locator, x_offset=None, y_offset=None, count=1):\r\n driver = self._current_application()\r\n el = self._element_find(locator, True, True)\r\n action = TouchAction(driver)\r\n action.tap(el, x_offset, y_offset, count).perform()",
"def double_tap(self, locator):\r\n ... | [
"0.73958546",
"0.6878971",
"0.6814113",
"0.6399038",
"0.6340633",
"0.58948916",
"0.5836868",
"0.57950395",
"0.5761519",
"0.5747372",
"0.57057613",
"0.56118274",
"0.5496889",
"0.5388753",
"0.52636874",
"0.5225673",
"0.52115715",
"0.5081884",
"0.5049696",
"0.50416523",
"0.50377... | 0.7536684 | 0 |
Swipe the screen to scroll down. | def swipe_up(self):
self.driver.swipe(start_x=self.x_cord, start_y=self.start_y,
end_x=self.x_cord, end_y=self.end_y, duration=1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swipe_down(self):\n self.swipe_sub(SWIPE_MATRIX[1])",
"def swipe_element_to_bottom_of_screen(self):\n window_size_y = self.driver.get_window_size()[\"height\"]\n self.swipe(30, window_size_y - 80, 30, window_size_y - 500)",
"def swipe_down(self, page_portion=0.25):\n driver = self.d... | [
"0.758218",
"0.71756256",
"0.71166104",
"0.7037795",
"0.6950055",
"0.69194794",
"0.68665427",
"0.6834109",
"0.67843467",
"0.676057",
"0.66562134",
"0.6606951",
"0.65145755",
"0.65032494",
"0.6459125",
"0.64556295",
"0.64275724",
"0.6410148",
"0.6391791",
"0.63822305",
"0.6373... | 0.7214927 | 1 |
Swipe the screen to move right. | def swipe_right(self, config):
self.driver.swipe(start_x=config['SWIPE_RIGHT']['x'],
start_y=config['SWIPE_RIGHT']['y'],
end_x=(config['SWIPE_RIGHT']['x'] - 400),
end_y=config['SWIPE_RIGHT']['y'], duration=1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swipe_right(self):\n self.swipe_sub(SWIPE_MATRIX[3])",
"def swipeRight (self) :\n rotated = Grid(np.rot90(self.grid))\n self.grid = np.rot90(np.rot90(np.rot90(rotated.swipeBase())))",
"def right(self):\n self.move(1,0)",
"def onMoveRight(self):\n self.mainGrid.moveRight()",... | [
"0.8454436",
"0.78103113",
"0.7573303",
"0.74607587",
"0.7398949",
"0.73591566",
"0.72639054",
"0.7250936",
"0.71935",
"0.7191789",
"0.7183003",
"0.7181764",
"0.71255744",
"0.71070856",
"0.70980036",
"0.70931053",
"0.7075506",
"0.7070613",
"0.70595074",
"0.70166427",
"0.69603... | 0.83857 | 1 |
Method to perform long press of element or a coordinate. | def press_long(self, hold_time, element=None, config=None, x_cord=None, y_cord=None):
if config:
self.touch.long_press(x=config[element]['x'],
y=config[element]['y'],
duration=hold_time).release().perform()
elif element:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_longpress(self, str_arg):\n arg = validateString(str_arg)\n # if arg.startswith(r'('):\n # raise ValueError('Bad argument, You may want to use longpress2 with coordinates as auguments.')\n x = 0\n y = 0\n seconds = 2000\n try:\n if arg.startswith(r... | [
"0.81420714",
"0.789084",
"0.7409583",
"0.74057496",
"0.6809658",
"0.6745555",
"0.6695679",
"0.66722083",
"0.6339727",
"0.6332918",
"0.6292188",
"0.62683517",
"0.61894494",
"0.6077479",
"0.6063342",
"0.6041611",
"0.6034741",
"0.6032851",
"0.5996023",
"0.59428483",
"0.59363294... | 0.7710179 | 2 |
Method to perform long press of element or a coordinate and slide. | def press_long_and_slide(self, element, x_cord, y_cord, hold_time):
if element:
self.touch.long_press(el=element, duration=hold_time).move_to(
x=x_cord, y=y_cord).release().perform()
else:
LOGGER.error('Element and co-ordinates must be given for long press!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_longpress(self, str_arg):\n arg = validateString(str_arg)\n # if arg.startswith(r'('):\n # raise ValueError('Bad argument, You may want to use longpress2 with coordinates as auguments.')\n x = 0\n y = 0\n seconds = 2000\n try:\n if arg.startswith(r... | [
"0.8066344",
"0.76812494",
"0.7387225",
"0.71065205",
"0.65214574",
"0.64916337",
"0.6470704",
"0.64311725",
"0.62847203",
"0.62028587",
"0.60926753",
"0.60913044",
"0.60368675",
"0.59834635",
"0.59390086",
"0.58624774",
"0.58039314",
"0.57924074",
"0.57913846",
"0.57878906",
... | 0.8362803 | 0 |
Select an key on the screen using keycode. | def press_using_keycode(self, text):
num = KEY_CODE_DICT[text]
self.driver.press_keycode(num)
time.sleep(3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keyevent(self, keycode: Union[str, int]) -> None:\n self.shell(['input', 'keyevent', str(keycode)])",
"def keypress(key):\n k = PyKeyboard()\n if key == 'enter':\n key = k.return_key\n k.tap_key(key)",
"def keypress(cls, _, key):\n return key",
"def presskey(self, key):\... | [
"0.72298855",
"0.70825064",
"0.7031476",
"0.7016587",
"0.7005039",
"0.6958417",
"0.6877484",
"0.6845089",
"0.67478025",
"0.674171",
"0.6733207",
"0.6687262",
"0.66723675",
"0.6649785",
"0.6627836",
"0.66275096",
"0.65697426",
"0.65491766",
"0.6541191",
"0.6495486",
"0.6452972... | 0.7188671 | 1 |
Press back button on mobile for 'num' times. | def press_back(self, num=1):
for _11 in range(0, num): # _11 as dummy variable
self.driver.back() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def press_back_button(self):\n self.driver.back()",
"def __call__(self, count = 1):\r\n assert type(count) == types.IntType and count >= 1, \\\r\n 'Invalid count value (%s) given!' % count\r\n\r\n self.phone.comment('back(%s)' % (count != 1 and str(count) or \"\"))\r\n\r\n ... | [
"0.686586",
"0.6603821",
"0.6489235",
"0.62731624",
"0.6251216",
"0.60601574",
"0.6037806",
"0.60344905",
"0.5995057",
"0.5986757",
"0.59838754",
"0.59783083",
"0.59600383",
"0.5889037",
"0.5838801",
"0.58346796",
"0.57942283",
"0.57372975",
"0.57372975",
"0.5688485",
"0.5674... | 0.7851241 | 0 |
Return element according to element type given. | def return_element(self, el_type, text, bounds=False):
if el_type == 'access':
element = self.driver.find_element_by_accessibility_id(text)
elif el_type == 'id':
element = self.driver.find_element_by_id(text)
elif el_type == 'xpath' and bounds:
element = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def element_type(self) -> global___Type:",
"def element(selection, sel_type='id'):\n selector = get_selector_method(sel_type)\n return selector(selection)",
"def element_by_atom_type(atom_type, verbose=False):\n matched_element = None\n\n if matched_element is None and atom_type.mass:\n matc... | [
"0.7039218",
"0.6531085",
"0.65199196",
"0.6413907",
"0.6378142",
"0.63359797",
"0.6290994",
"0.6273379",
"0.62482876",
"0.62119603",
"0.6187754",
"0.61422116",
"0.60904515",
"0.6073134",
"0.60068643",
"0.5997687",
"0.59854156",
"0.59780675",
"0.59744245",
"0.59307486",
"0.59... | 0.71218866 | 0 |
Return list of elements of class 'android.widget.TextView'. | def return_textview_elements(self):
return self.driver.find_elements_by_class_name('android.widget.TextView') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def texts(self):\n return [elem.text for elem in self.web_elements]",
"def get_elements_text(self, elements: Union[List[WebElement], Tuple[By, str]]) -> List[str]:\n elements = self.find_elements(elements)\n return [element.get_attribute('innerText') for element in elements]",
"def get_all... | [
"0.6248276",
"0.60573405",
"0.60127634",
"0.5948078",
"0.5905251",
"0.577305",
"0.5733306",
"0.56923234",
"0.5615578",
"0.556697",
"0.5562241",
"0.5440046",
"0.5421704",
"0.53165835",
"0.53053695",
"0.5239165",
"0.52215254",
"0.5188379",
"0.51882476",
"0.517459",
"0.51421756"... | 0.85841584 | 0 |
Return element matching the text which is passed to it. | def return_button(self, text, class_name='android.widget.TextView'):
for button in self.driver.find_elements_by_class_name(class_name):
if button.text == text:
return button
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_text_in_element():\n nonlocal text_\n if text_ is None:\n text_ = element.text\n element_text = element.text\n if element_text == text:\n return element\n if text.lower() == element_text.lower():\n return el... | [
"0.7376054",
"0.71084297",
"0.6891974",
"0.67400026",
"0.662405",
"0.64236134",
"0.6199454",
"0.61929",
"0.6180942",
"0.61549133",
"0.6146275",
"0.6094788",
"0.6044545",
"0.60304886",
"0.6012001",
"0.5969076",
"0.5952407",
"0.5950843",
"0.5950843",
"0.5889585",
"0.58815986",
... | 0.6416724 | 6 |
Click a specified element if present. Handles error inside the method if parameter is set. | def click_element(self, el_type, text, delay=3, handle_error=True):
if el_type not in ['access', 'xpath']:
LOGGER.error('Mentioned element does not exist!')
button = None
else:
button = self.return_element(el_type=el_type, text=text)
if handle_error:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def elementClick(self,locator=\"\",locatorType='id',element=None):\n\n\n try:\n if locator:\n element=self.getElement(locator,locatorType)\n\n element.click()\n self.logger.info(\"clicked on element with locator\"+locator+\" locatorType: \"+locatorType)\n\n ... | [
"0.7175649",
"0.70856076",
"0.7043328",
"0.6983573",
"0.6871981",
"0.6846188",
"0.6828609",
"0.667858",
"0.657414",
"0.6499648",
"0.6435625",
"0.6419192",
"0.63694227",
"0.6356947",
"0.63161623",
"0.630584",
"0.62764186",
"0.6267747",
"0.6248839",
"0.62318325",
"0.62288755",
... | 0.6763409 | 7 |
Return element according to 'text' or 'search text' and clicks it. | def click_using_class(self, text, search_text=None, delay=3, is_button=False):
if search_text:
class_name = 'android.widget.EditText'
button = self.return_button(search_text, class_name)
elif is_button:
class_name = 'android.widget.Button'
button = self.re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def return_button(self, text, class_name='android.widget.TextView'):\n for button in self.driver.find_elements_by_class_name(class_name):\n if button.text == text:\n return button\n return None",
"def click_search_button(self):\n self.click_element(self.generic_sear... | [
"0.661339",
"0.65298027",
"0.64589846",
"0.63079387",
"0.6279679",
"0.6225251",
"0.61082816",
"0.60499865",
"0.5844906",
"0.5839642",
"0.58275473",
"0.58186126",
"0.5792587",
"0.57632035",
"0.57194805",
"0.569059",
"0.568484",
"0.5681119",
"0.5595558",
"0.5590351",
"0.5569256... | 0.72133875 | 0 |
Open application on mobile device. | def start_app(self):
app_xpath = '//android.widget.FrameLayout[@content-desc=\"{app}\"]/android.widget.ImageView'
LOGGER.info('Starting app now!')
tex = app_xpath.format(app=self.app_name)
try:
self.click_element(el_type='xpath', text=tex, handle_error=False)
except N... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_mobile_application(self, platform):\n if platform == ANDROID:\n self.appium_lib.open_application(APPIUM_URL_ANDROID, platformName = APPIUM_DESIRED_CAPS['platformName'],\n deviceName = APPIUM_DESIRED_CAPS['udid'],\n ... | [
"0.77800596",
"0.7442968",
"0.7184208",
"0.62102145",
"0.6025373",
"0.6014739",
"0.591356",
"0.58947474",
"0.58312345",
"0.58172476",
"0.57678336",
"0.5743146",
"0.5674543",
"0.5626196",
"0.56029844",
"0.5575846",
"0.55363363",
"0.5530113",
"0.55267155",
"0.5506385",
"0.55040... | 0.68002564 | 3 |
Count letters in a name. | def counter(name):
count_name = list(name)
counter = 0
for letter in count_name:
counter += 1
print(f"There are {counter} letter in the name {name}.")
print(f"\tAnd btw... {name} backwards is {name[::-1].lower()}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def char_count(self, _list, char):\n\t\tcont = 0\n\t\tfor i in _list:\n\t\t\tcont += i[\"name\"].count(char.upper())\n\t\t\tcont += i[\"name\"].count(char.lower())\n\t\treturn cont",
"def test_single_letter_count(self):\n self.assertEqual(functions.single_letter_count(\"Hello World\", \"h\"), 1)\n ... | [
"0.75467575",
"0.74104375",
"0.74040395",
"0.739459",
"0.73699015",
"0.7357591",
"0.7343402",
"0.7343402",
"0.7343402",
"0.7343402",
"0.731937",
"0.7260459",
"0.72601306",
"0.72523135",
"0.72024745",
"0.7005587",
"0.69186723",
"0.6886823",
"0.68676317",
"0.68437684",
"0.67980... | 0.74775517 | 1 |
Converts the given str (str_in) to a datetime.date or datetime.datetime object, using the format optionally given as the parameter format_in. | def str2date(str_in, format_in="yyyy-mm-dd", typeout=None):
if type(str_in) is not str:
raise TypeError("str_in must be a str")
if type(format_in) is not str:
raise TypeError("format_in must be a str")
if typeout is not dt.date and typeout is not dt.datetime and typeout is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_date_from_string(self, datestr, fmt):\n return datetime.datetime.strptime(datestr, fmt)",
"def str2date(date_str, date_format):\n return datetime.strptime(date_str, date_format)",
"def _convert_date(date_string, s_format='%Y-%m-%d'):\r\n if isinstance(date_string, str):\r\n return d... | [
"0.76346546",
"0.74792445",
"0.7137026",
"0.7019489",
"0.7005402",
"0.691273",
"0.68818885",
"0.687637",
"0.684877",
"0.68447477",
"0.6791915",
"0.67769426",
"0.6754171",
"0.6749142",
"0.672639",
"0.6686086",
"0.6681176",
"0.6680179",
"0.66634023",
"0.6661955",
"0.66202503",
... | 0.73334426 | 2 |
Try to get the date that a file was created, falling back to when it was last modified if that isn't possible. | def created(path):
# TODO: Test this code block on other platforms (OS X/Linux)
if platform.system() == 'Windows':
date = datetime.fromtimestamp(os.path.getctime(path)).strftime('%Y-%m-%d')
return date
else:
stat = os.stat(path)
try:
return stat.st_birthtime
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _creation_date(path_to_file):\n if platform.system() == \"Windows\":\n return os.path.getctime(path_to_file)\n else:\n stat = os.stat(path_to_file)\n try:\n return stat.st_birthtime\n except AttributeError:\n # We're probably on Linux. No easy way to get ... | [
"0.8190197",
"0.805753",
"0.8000129",
"0.7986132",
"0.7986132",
"0.7926146",
"0.76267004",
"0.7622058",
"0.7512643",
"0.7511644",
"0.744479",
"0.7173829",
"0.7128207",
"0.696563",
"0.6958586",
"0.69365454",
"0.6904673",
"0.68706644",
"0.67324805",
"0.66605735",
"0.66230446",
... | 0.79197496 | 6 |
Detect object classes in an image using precomputed object proposals. | def detect(self, image):
# Load the demo image
# Detect all object classes and regress object bounds
image = image_transform_1_3(image)
timer = Timer()
timer.tic()
scores, boxes = self.im_detect(image)
timer.toc()
print('rois--------------', scores)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def detect_objects(interpreter, image):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n count = int(get_output_ten... | [
"0.71595085",
"0.7112627",
"0.7053825",
"0.695533",
"0.6803062",
"0.6613106",
"0.65618676",
"0.6435698",
"0.6388294",
"0.6292531",
"0.62065536",
"0.6154667",
"0.6117337",
"0.6116278",
"0.6087541",
"0.6083871",
"0.6029203",
"0.59899825",
"0.5947565",
"0.59351975",
"0.59153056"... | 0.69261765 | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.