2: # if the state/country code is invalid\\r\\n return \\\"Not valid state code/country code\\\"\\r\\n url = f'https://api.openweathermap.org/data/2.5/weather?q={new_city_name},{new_city[1]},us&appid={API}'\\r\\n elif ',' not in city_name: # if searched by only city and not state or country code, works for big cities\\r\\n url = f'http://api.openweathermap.org/data/2.5/weather?q={city_name}&appid={API}'\\r\\n response = requests.get(url).json() # getting the proper json data based on the input of the city_name\\r\\n city_latitude = str(response['coord']['lat'])\\r\\n city_longitude = str(response['coord']['lon'])\\r\\n if (new_city[1].upper() in states) and (\\r\\n response['sys']['country'] != 'US'): # to catch foreign cities with US state codes\\r\\n return \\\"Not valid city\\\"\\r\\n elif (new_city[1].upper() not in states) and (\\r\\n new_city[1].upper() != response['sys']['country'] and new_city != 'XXX'):\\r\\n # to catch US cities with foreign country codes\\r\\n return 'Not a valid city'\\r\\n elif states[new_city[1].upper()] != coordinates(city_latitude,\\r\\n city_longitude):\\r\\n # Check to see if city is located in provided state\\r\\n return 'City is not located in that state'\\r\\n current_temp = response['main']['temp']\\r\\n max_temp = response['main']['temp_max']\\r\\n min_temp = response['main']['temp_min']\\r\\n feels_like_temp = response['main']['feels_like']\\r\\n curr_temp_fheit = round((current_temp * 1.8) - 459.67) # converting to imperial\\r\\n max_temp_fheit = round((max_temp * 1.8) - 459.67)\\r\\n min_temp_fheit = round((min_temp * 1.8) - 459.67)\\r\\n feels_like_temp_fheit = round((feels_like_temp * 1.8) - 459.67)\\r\\n description = response['weather'][0]['description']\\r\\n wind = round(response['wind']['speed'] * 2.23694)\\r\\n\\r\\n format_weather = (\\\"Current weather for \\\" + str(city_name) + \\\", \\\" + response['sys']['country'] +\\r\\n \\\"\\\\nCurrent temp: \\\" + str(curr_temp_fheit) + '\\\\nMax Temp: ' + str(\\r\\n max_temp_fheit) + '\\\\nMin Temp: ' + str(\\r\\n min_temp_fheit) + '\\\\nFeels like: ' + str(\\r\\n feels_like_temp_fheit) + '\\\\nOutlook: ' + description + '\\\\nWind: ' + str(\\r\\n wind) + ' mph')\\r\\n # print weather in cleaner format\\r\\n return format_weather\\r\\n\\r\\n except KeyError: # If a city that doesn't exist is entered\\r\\n return 'Not valid city'\",\n \"def parse_city_state_from_row(row):\\n city, state = ['NULL', 'NULL']\\n if row['Geographic area'].count(' - ') == 2:\\n state, city = row['Geographic area'].lower().split(' - ')[-2:]\\n city = remove_substring_from_end_of_string(city, [' city', ' cdp'])\\n return pandas.Series([city, state])\",\n \"def getClosestLocation(self, locations):\\n obs = self.observation\\n if len(locations) > 0:\\n min_i = 0\\n min_dist = point_dist(obs.loc, locations[0][0:2])\\n for i in range(1, len(locations)):\\n dist = point_dist(obs.loc, locations[i][0:2])\\n if dist < min_dist:\\n min_i = i\\n min_dist = dist\\n return locations[min_i][0:2]\\n else:\\n return None\",\n \"def forecast_for_closest(\\n lat: float, lon: float, lang=_DEFAULT_LANG, num_stations_to_try: int = 3\\n) -> Tuple[Dict, Dict]:\\n assert lang in _SUPPORTED_LANGS\\n\\n stations = closest_stations(lat, lon, limit=num_stations_to_try)\\n for s in stations:\\n o = forecast_for_station(s[\\\"id\\\"], lang=lang)\\n if o[\\\"results\\\"] and not o[\\\"results\\\"][0].get(\\\"err\\\") and o[\\\"results\\\"][0][\\\"valid\\\"]:\\n return o, s\\n\\n return forecast_for_station(stations[0][\\\"id\\\"], lang=lang), stations[0]\",\n \"def geocodeLocations(locations):\\n maxResults = 1\\n location_query = ''\\n for location in locations:\\n location_query += \\\"&location=%s\\\" % encodeUrl(location)\\n url = \\\"http://open.mapquestapi.com/geocoding/v1/batch?maxResults=%d%s\\\" % (maxResults, location_query)\\n print url\\n results = json.loads(urllib2.urlopen(url).read())\\n print results\\n return\\n for location_result in results['results']:\\n #print location_result\\n if location_result['providedLocation']['location'] == location:\\n latlng = location_result['locations'][0]['displayLatLng']\\n return latlng\\n else:\\n print location_result\",\n \"def match_city(self, city, dpt_code, zip_code = None):\\n city = format_str_city_insee(city)\\n dpt_code = dpt_code.rjust(2, '0')\\n if zip_code:\\n zip_code.rjust(5, '0')\\n # Based on zip code and city name\\n ls_matching = []\\n found_indicator = False\\n if zip_code:\\n if zip_code in self.dict_corr_zip_insee:\\n for city_insee, zip_insee, dpt_insee, code_insee in self.dict_corr_zip_insee[zip_code]:\\n if city == city_insee:\\n ls_matching.append((city_insee, zip_insee, code_insee))\\n found_indicator = True\\n if found_indicator:\\n return (ls_matching, 'zip_city_match')\\n # If no exact zip, city match: check if city name in insee city names\\n for city_insee, zip_insee, dpt_insee, code_insee in self.dict_corr_zip_insee[zip_code]:\\n if city in city_insee:\\n ls_matching.append((city_insee, zip_insee, code_insee))\\n found_indicator = True\\n if found_indicator:\\n return (ls_matching, 'zip_city_in_match(es)')\\n # Based on dpt code and city name\\n for city_insee, zip_insee, dpt_insee, code_insee in self.dict_corr_dpt_insee[dpt_code]:\\n if city == city_insee:\\n ls_matching.append((city_insee, zip_insee, code_insee))\\n found_indicator = True\\n if found_indicator:\\n return (ls_matching, 'dpt_city_match')\\n # If no exact dpt, city match: check if city name in insee city names\\n for city_insee, zip_insee, dpt_insee, code_insee in self.dict_corr_dpt_insee[dpt_code]:\\n if city in city_insee:\\n ls_matching.append((city_insee, zip_insee, code_insee))\\n found_indicator = True\\n if found_indicator:\\n return (ls_matching, 'dpt_city_in_match(es)')\\n # No match\\n return (None, 'no_match')\",\n \"def lookup():\\n \\\"\\\"\\\" OR station info for current selection\\\"\\\"\\\"\\n\\n # check which arguements are present\\n if request.args.get(\\\"city\\\") and request.args.get(\\\"state\\\"):\\n # get all stations for a location\\n\\n city = request.args.get(\\\"city\\\")\\n state = request.args.get(\\\"state\\\")\\n\\n station_list = Station.query.join(Place).\\\\\\n filter(Place.city == city, Place.state == state).all()\\n\\n result = geo_stations.dump(station_list)\\n\\n if request.args.get(\\\"stream\\\"):\\n # get station for specified url\\n\\n url = request.args.get(\\\"stream\\\")\\n\\n station_list = Station.query.join(Place).\\\\\\n filter(Station.url_stream == url).all()\\n\\n result = geo_stations.dump(station_list)\\n\\n return jsonify(result.data)\",\n \"def _get_and_cache_gps_coords(enodeb: EnodebAcsStateMachine) -> tuple:\\n lat, lon = '', ''\\n try:\\n lat = enodeb.get_parameter(ParameterName.GPS_LAT)\\n lon = enodeb.get_parameter(ParameterName.GPS_LONG)\\n\\n if lat != _gps_lat_cached or lon != _gps_lon_cached:\\n _cache_new_gps_coords(lat, lon)\\n return lat, lon\\n except (KeyError, ConfigurationError):\\n return _get_cached_gps_coords()\\n except ValueError:\\n logging.warning('GPS lat/long not understood (%s/%s)', lat, lon)\\n return '0', '0'\",\n \"def test_find_city(self):\\n\\n # Given\\n game_state: CarcassonneGameState = CarcassonneGameState()\\n\\n city_top = base_tiles[\\\"city_top\\\"]\\n city_bottom = city_top.turn(2)\\n\\n game_state.board = [[None for column in range(1)] for row in range(2)]\\n\\n game_state.board[0][0] = city_bottom\\n game_state.board[1][0] = city_top\\n\\n # When\\n city: City = CityUtil.find_city(\\n game_state=game_state,\\n city_position=CoordinateWithSide(Coordinate(0, 0), Side.BOTTOM)\\n )\\n\\n # Then\\n self.assertTrue(city.finished)\\n self.assertEqual(2, len(city.city_positions))\\n self.assertIn(CoordinateWithSide(Coordinate(0, 0), Side.BOTTOM), city.city_positions)\\n self.assertIn(CoordinateWithSide(Coordinate(1, 0), Side.TOP), city.city_positions)\",\n \"def get_city(self, territory_id: str = \\\"\\\"):\",\n \"def get_city(self, territory_id: str = \\\"\\\"):\",\n \"def get_by_city():\\n while True:\\n try:\\n for key in CITY_DICT:\\n print(key)\\n city = input(\\\"Enter city name: \\\")\\n lat, long = CITY_DICT.get(city.capitalize())\\n return lat, long\\n except TypeError:\\n print(\\\"~\\\" * 50)\\n print(\\\"Please enter the city name correctly\\\")\",\n \"def get_formatted_location(city, country):\\n\\tformatted_location = city + \\\", \\\" + country\\n\\treturn formatted_location.title()\",\n \"def resolve_query_place(query):\\n\\n\\tallTokens = [token for token in query.replace(',', ' ').split(' ') if token]\\n\\tif not len(allTokens):\\n\\t\\treturn ('', None)\\n\\tcomponents = [component.split(' ') for component in query.split(',') if component]\\n\\tcities = None\\n\\tregions = None\\n\\tcountries = None\\n\\tplaces = None\\n\\tconsumed = 0\\n\\t\\n\\tdef get_component():\\n\\t\\t\\\"\\\"\\\" Returns a sub sequence of a component. This makes use of the commas as hard delimiters to separate city, state, etc. \\\"\\\"\\\"\\n\\t\\tcomponentConsumed = consumed\\n\\t\\tfor i in range(len(components)):\\n\\t\\t\\tif componentConsumed < len(components[-i]):\\n\\t\\t\\t\\treturn components[-i][:-componentConsumed if componentConsumed else None]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcomponentConsumed -= len(components[-i])\\n\\t\\treturn []\\n\\n\\tif len(allTokens[-1]) == 2 and allTokens[-1].isalpha():\\n\\t\\tif len(allTokens) >= 2 and len(allTokens[-2]) == 2 and allTokens[-2].isalpha():\\n\\t\\t\\t# A county and region code were given. e.g. CA US -> US.CA\\n\\t\\t\\tregions = Region.objects.filter(code='%s.%s' % (allTokens[-1].upper(), allTokens[-2].upper()))\\n\\t\\t\\tconsumed = 2\\n\\t\\telse:\\n\\t\\t\\t# A single region or country code was given\\n\\t\\t\\tregions = Region.objects.filter(code__endswith=allTokens[-1].upper())\\n\\t\\t\\tif not len(regions):\\n\\t\\t\\t\\tcountries = Country.objects.filter(code=allTokens[-1].upper()).order_by('-population')\\n\\t\\t\\tconsumed = 1\\n\\t\\tif len(regions):\\n\\t\\t\\t# Found a region, also try to find the city that goes with the region\\n\\t\\t\\tplaces = regions\\n\\t\\t\\tcityConsumed = __parse_city(get_component())\\n\\t\\t\\tif cityConsumed:\\n\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None]), region__in=regions).order_by('-population')\\n\\t\\t\\t\\tif len(cities):\\n\\t\\t\\t\\t\\tplaces = cities\\n\\t\\t\\t\\t\\tconsumed += cityConsumed\\n\\t\\telif len(countries):\\n\\t\\t\\t# Found a country, also try to find the city that goes with the country\\n\\t\\t\\tplaces = countries\\n\\t\\t\\tcityConsumed = __parse_city(get_component())\\n\\t\\t\\tif cityConsumed:\\n\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None]), country=countries[0]).order_by('-population')\\n\\t\\t\\t\\tif len(cities):\\n\\t\\t\\t\\t\\tplaces = cities\\n\\t\\t\\t\\t\\tconsumed += cityConsumed\\n\\telse:\\n\\t\\t# No codes were given, the query is more free form\\n\\t\\t# Match the country first\\n\\t\\tcountryConsumed = __parse_country(get_component())\\n\\t\\tif countryConsumed:\\n\\t\\t\\tcountries = Country.objects.filter(name__iexact=' '.join(allTokens[-(consumed + countryConsumed):-consumed if consumed else None])).order_by('-population')\\n\\t\\t\\tif len(countries):\\n\\t\\t\\t\\tplaces = countries\\n\\t\\t\\t\\tconsumed += countryConsumed\\n\\t\\t# Try region then city matching\\n\\t\\tregionConsumed = __parse_region(get_component())\\n\\t\\tif regionConsumed:\\n\\t\\t\\tif countries and len(countries):\\n\\t\\t\\t\\tregions = Region.objects.filter(name__iexact=' '.join(allTokens[-(consumed + regionConsumed):-consumed if consumed else None]), country=countries[0])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tregions = Region.objects.filter(name__iexact=' '.join(allTokens[-(consumed + countryConsumed):-consumed if consumed else None]))\\n\\t\\t\\tif len(regions):\\n\\t\\t\\t\\tplaces = regions\\n\\t\\t\\t\\tconsumed += regionConsumed\\n\\t\\tcityConsumed = __parse_city(get_component())\\n\\t\\tif cityConsumed:\\n\\t\\t\\tif regions and len(regions):\\n\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None]), region__in=regions).order_by('-population')\\n\\t\\t\\telif len(countries):\\n\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None]), country=countries[0]).order_by('-population')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None])).order_by('-population')\\n\\t\\t\\tif len(cities):\\n\\t\\t\\t\\tplaces = cities\\n\\t\\t\\t\\tconsumed += cityConsumed\\n\\t\\t# If region was found without a city go back to just try to resolve it to a city instead\\n\\t\\tif (regions and len(regions)) and (not cities or not len(cities)):\\n\\t\\t\\tconsumed -= regionConsumed\\n\\t\\t\\tcityConsumed = __parse_city(get_component())\\n\\t\\t\\tif cityConsumed:\\n\\t\\t\\t\\tif len(countries):\\n\\t\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None]), country=countries[0]).order_by('-population')\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tcities = City.objects.filter(name__iexact=' '.join(allTokens[-(consumed + cityConsumed):-consumed if consumed else None])).order_by('-population')\\n\\t\\t\\t\\tif len(cities):\\n\\t\\t\\t\\t\\tplaces = cities\\n\\t\\t\\t\\t\\tconsumed += cityConsumed\\n\\t\\t\\tif not cities or not len(cities):\\n\\t\\t\\t\\t# No city found, region is the best match\\n\\t\\t\\t\\tconsumed -= regionConsumed\\n\\n\\treturn (' '.join(allTokens[:-consumed if consumed else None]), places)\",\n \"def find_city(city, used_city, min_path):\\n for key in city[used_city].keys():\\n if city[used_city][key] == min_path:\\n return key\",\n \"def get_city_job(html):\\n soup = BeautifulSoup(html, 'html.parser')\\n city = soup.find(class_=\\\"subtle loc\\\").get_text()\\n if city:\\n return city\\n return None\",\n \"def test_nearest_location_odd():\\n assert nearest_location([(3, 6), (9, 13)], 7) == 0\\n assert nearest_location([(3, 6), (9, 13)], 7, 1) == 1\",\n \"def closest_other(state):\\n locations = others_locations(state)\\n distances_ = distances(my_location(state), list(locations.values()))\\n dist_dict = {key: dist for key, dist in zip(locations, distances_)}\\n target = util.argmin_dict(dist_dict)\\n return target\",\n \"def coordinates(latitude, longitude):\\r\\n location = geolocator.reverse(latitude + \\\", \\\" + longitude)\\r\\n data = location.raw\\r\\n data = data['address']\\r\\n state_code = data['state']\\r\\n return state_code\",\n \"def return_location(doctype, filters_sql):\\n\\tif filters_sql:\\n\\t\\ttry:\\n\\t\\t\\tcoords = frappe.db.sql(\\n\\t\\t\\t\\tf\\\"\\\"\\\"SELECT name, location FROM `tab{doctype}` WHERE {filters_sql}\\\"\\\"\\\", as_dict=True\\n\\t\\t\\t)\\n\\t\\texcept frappe.db.InternalError:\\n\\t\\t\\tfrappe.msgprint(frappe._(\\\"This Doctype does not contain location fields\\\"), raise_exception=True)\\n\\t\\t\\treturn\\n\\telse:\\n\\t\\tcoords = frappe.get_all(doctype, fields=[\\\"name\\\", \\\"location\\\"])\\n\\treturn coords\",\n \"def return_city(n):\\n if n == 1:\\n return \\\"San Francisco\\\"\\n elif n == 2:\\n return \\\"Los Angeles\\\"\\n elif n == 3:\\n return \\\"Las Vegas\\\"\\n elif n == 4:\\n return \\\"Portland\\\"\\n elif n == 5:\\n return \\\"San Diego\\\"\\n else:\\n return \\\"Seattle\\\"\",\n \"def get_by_altitute():\\n try:\\n lat, long = input(\\\"Enter Lat and Long of a place: \\\").split()\\n return lat, long\\n except ValueError:\\n print(\\\"Error while getting values.\\\")\\n get_by_altitute()\",\n \"def valid_location(location):\\n\\n lat_lng_url = \\\"http://maps.googleapis.com/maps/api/geocode/json?address=\\\" + location\\n lat_lng_url_response = requests.get(lat_lng_url)\\n location_data = lat_lng_url_response.json()\\n if location_data[\\\"status\\\"] == \\\"OK\\\":\\n lat_lng = location_data[\\\"results\\\"][0][\\\"geometry\\\"][\\\"location\\\"]\\n lat, lng = lat_lng[\\\"lat\\\"], lat_lng[\\\"lng\\\"]\\n return lat, lng\\n else:\\n new_location = raw_input(\\\"Invalid location, please try again. \\\")\\n return valid_location(new_location)\",\n \"def test_nearest_location_even():\\n assert nearest_location([(3, 6), (8, 13)], 6, 0) == 0\\n assert nearest_location([(3, 6), (8, 13)], 6, 1) == 0\\n assert nearest_location([(3, 6), (8, 13)], 7, 0) == 1\\n assert nearest_location([(3, 6), (8, 13)], 7, 1) == 1\",\n \"def return_address_from_location(location='0,0'):\\n if not re.compile('^(\\\\-?\\\\d+(\\\\.\\\\d+)?),\\\\s*(\\\\-?\\\\d+(\\\\.\\\\d+)?)$').match(location):\\n raise ValueError('Location Invalid')\\n base_url = 'https://maps.googleapis.com/maps/api/geocode/json?'\\n latlng = 'latlng=' + location\\n try:\\n #This try block is for our first 150,000 requests. If we exceed this, use Jack's Token.\\n key_string = '&key=' + ACCESS_TOKEN\\n url = base_url + latlng + key_string #Builds the url\\n result = requests.get(url).json() #Gets google maps json file\\n cleaned = result['results'][0]['address_components']\\n #Address to check against value of check_against_business_location\\n chk = cleaned[0]['long_name'] + ' ' + cleaned[1]['long_name'] + ', ' + cleaned[3]['long_name']\\n business_tuple = check_against_business_location(location, chk)\\n if business_tuple[0]: #If true, the lat, lon matches a business location and we return business name\\n return business_tuple[1]\\n else: #otherwise, we just return the address\\n return cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name'] + ', ' + cleaned[3]['short_name']\\n except:\\n try:\\n #Use Jack's Token in case of some invalid request problem with other API Token\\n key_string = '&key=' + JACK_TOKEN\\n url = base_url + latlng + key_string #Builds the url\\n result = requests.get(url).json() #Gets google maps json file\\n cleaned = result['results'][0]['address_components']\\n #Address to check against value of check_against_business_location\\n chk = cleaned[0]['long_name'] + ' ' + cleaned[1]['long_name'] + ', ' + cleaned[3]['long_name']\\n business_tuple = check_against_business_location(location, chk)\\n if business_tuple[0]: #If true, the lat, lon matches a business location and we return business name\\n return business_tuple[1]\\n else: #otherwise, we just return the address\\n return cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name'] + ', ' + cleaned[3]['short_name']\\n except:\\n raise ValueError(\\\"Something went wrong\\\")\",\n \"def get_random_city(self):\\n psycopg2.extensions.register_type(psycopg2.extensions.UNICODE, self.cursor)\\n psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY, self.cursor)\\n query = \\\"SELECT _id, name, country, lat, lon FROM cities INNER JOIN coord \\\" \\\\\\n \\\"ON cities.coord = coord.id ORDER BY random() LIMIT 1;\\\"\\n self.select_from_bd(query)\\n return self.cursor.fetchone()\",\n \"def get_city_country(city, country, population=''):\\n\\tif population:\\n\\t\\tcity_country = city.title() + ', ' + country.title() + \\\" - population \\\" + str(population)\\n\\telse:\\n\\t\\tcity_country = city.title() + ', ' + country.title()\\n\\treturn city_country\",\n \"def _get_closest_station_by_zcta_ranked(zcta):\\n\\n zcta = zcta.zfill(5) # Ensure that we have 5 characters, and if not left-pad it with zeroes.\\n lat, lon = zcta_to_lat_long(zcta)\\n finding_station = True\\n rank = 0\\n while finding_station:\\n rank = rank + 1\\n station_ranking = _rank_stations_by_distance_and_quality(lat, lon)\\n station, warnings = select_station(station_ranking, rank=rank)\\n\\n # Ignore stations that begin with A\\n if str(station)[0] != 'A':\\n finding_station = False\\n\\n return station, warnings, lat, lon\",\n \"def return_address_from_location_yelp(location='0,0'):\\n if not re.compile('^(\\\\-?\\\\d+(\\\\.\\\\d+)?),\\\\s*(\\\\-?\\\\d+(\\\\.\\\\d+)?)$').match(location):\\n raise ValueError('Location Invalid')\\n base_url = 'https://maps.googleapis.com/maps/api/geocode/json?'\\n latlng = 'latlng=' + location\\n try:\\n #This try block is for our first 150,000 requests. If we exceed this, use Jack's Token.\\n key_string = '&key=' + ACCESS_TOKEN\\n url = base_url + latlng + key_string #Builds the url\\n print(url)\\n result = requests.get(url).json() #Gets google maps json file\\n cleaned = result['results'][0]['address_components']\\n\\n #Address to check against value of check_against_business_location\\n chk = cleaned[0]['long_name'] + ' ' + cleaned[1]['long_name'] + ', ' + cleaned[3]['long_name']\\n business_tuple = check_against_business_location(location, chk)\\n \\n if business_tuple[0]: #If true, the lat, lon matches a business location and we return business name\\n address_comp = cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name']\\n # print(business_tuple[1])\\n # print(cleaned[3]['short_name'])\\n # print(address_comp)\\n return business_tuple[1], cleaned[3]['short_name'], address_comp\\n else: #otherwise, we just return the address\\n # print(cleaned[0]['long_name'])\\n # print(cleaned[1]['short_name'])\\n # print(cleaned[3]['short_name'])\\n return cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name'] + ', ' + cleaned[3]['short_name']\\n except:\\n try:\\n #Use Jack's Token in case of some invalid request problem with other API Token\\n key_string = '&key=' + JACK_TOKEN\\n url = base_url + latlng + key_string #Builds the url\\n result = requests.get(url).json() #Gets google maps json file\\n cleaned = result['results'][0]['address_components']\\n #Address to check against value of check_against_business_location\\n chk = cleaned[0]['long_name'] + ' ' + cleaned[1]['long_name'] + ', ' + cleaned[3]['long_name']\\n business_tuple = check_against_business_location(location, chk)\\n if business_tuple[0]: #If true, the lat, lon matches a business location and we return business name\\n address_comp = cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name'] \\n # print(address_comp)\\n # print(business_tuple[1])\\n # print(cleaned[3]['short_name'])\\n return business_tuple[1], cleaned[3]['short_name'], address_comp\\n else: #otherwise, we just return the address\\n # print(cleaned[0]['long_name'])\\n # print(cleaned[1]['short_name'])\\n # print(cleaned[3]['short_name'])\\n return cleaned[0]['long_name'] + ' ' + cleaned[1]['short_name'] + ', ' + cleaned[3]['short_name']\\n except:\\n raise ValueError(\\\"Something went wrong\\\")\",\n \"async def find_by_coordinates(self, latitude: float, longitude: float):\\n data = self.geocode_service.reverse_geocoding(latitude, longitude)\\n if data is not None:\\n return await self.address_service.search_addresses(data[\\\"street\\\"])\\n return None\",\n \"def observation_for_closest(\\n lat: float, lon: float, lang: str = _DEFAULT_LANG, num_stations_to_try: int = 3\\n) -> Tuple[Dict, Dict]:\\n assert lang in _SUPPORTED_LANGS\\n\\n stations = closest_stations(lat, lon, limit=num_stations_to_try)\\n for s in stations:\\n o = observation_for_station(s[\\\"id\\\"], lang=lang)\\n if o[\\\"results\\\"] and not o[\\\"results\\\"][0].get(\\\"err\\\") and o[\\\"results\\\"][0][\\\"valid\\\"]:\\n return o, s\\n return observation_for_station(stations[0][\\\"id\\\"], lang=lang), stations[0]\",\n \"def get_by_locale(locality, country, cursor=None):\\n\\n if not cursor:\\n cursor = get_database_cursor()\\n cursor.execute(\\\"select * from location where locality=? and country=?\\\", (locality, country))\\n return cursor.fetchone()\",\n \"def get_user_location(return_type=None):\\n\\n gmaps = googlemaps.Client(key=GooglemapsService.api_key)\\n json_response = gmaps.geolocate()\\n user_location_coords = \\\"%s,%s\\\" % (json_response['location']['lat'], json_response['location']['lng'])\\n\\n if return_type is None:\\n return_type = \\\"coords\\\"\\n\\n if return_type == \\\"address\\\":\\n return GooglemapsService.get_reverse_geocode_result(user_location_coords)\\n else:\\n return user_location_coords\",\n \"def get_city_from_osm(city_name, network_type=\\\"drive\\\"):\\n city_paths_nodes = None\\n for which_result in range(1, 4):\\n try:\\n city_boundaries = ox.gdf_from_place(city_name, which_result=which_result)\\n city_paths_nodes = ox.osm_net_download(city_boundaries['geometry'].unary_union, network_type=network_type)\\n break\\n except Exception as e:\\n logger.exception(e)\\n return None\\n\\n return city_paths_nodes\",\n \"def get_coordinates(addresses, boroughs):\\n latitude = []\\n longitude = []\\n for address, borough in zip(addresses, boroughs):\\n try:\\n g = geocoder.osm('{}, {}, New York'.format(address, borough)).json\\n latitude.append(g['lat'])\\n longitude.append(g['lng'])\\n except:\\n latitude.append(None)\\n longitude.append(None)\\n\\n return np.array(latitude).T, np.array(longitude).T\",\n \"def Fetch_station(long, lat, y):\\r\\n global ddf\\r\\n dmin = 1000000\\r\\n rs = 0\\r\\n i=0\\r\\n for i in range(len(ddf[y])):\\r\\n #Calculate the distance between zip code location and weather station location\\r\\n dnew = Distance_orthonormique(ddf[y]['LON'][i], ddf[y]['LAT'][i], long, lat)\\r\\n\\r\\n if(dmin > dnew):\\r\\n #If the last smaller distance is superior than the current distance :\\r\\n #the new smaller distance is the current distance\\r\\n dmin = dnew\\r\\n rs = i\\r\\n\\r\\n #rs = index dataframe weather station\\r\\n #ddf[y]['STATION NAME'][rs] = Weather station name\\r\\n #round(dmin, 2) = Distance between weather station and zip code\\r\\n \\r\\n return rs, ddf[y]['STATION NAME'][rs], round(dmin,2)\",\n \"def get_user_location(loc):\\n if not loc:\\n return {'lat': 37.8715926, 'lng': -122.272747}\\n geocode_result = gmaps.geocode(loc)\\n if not geocode_result:\\n location = {'lat': 37.8715926, 'lng': -122.272747}\\n else:\\n location = geocode_result[0]['geometry']['location']\\n return location\",\n \"def location2station(location):\\r\\n # just forget it, use google\\r\\n location = quote(str(location))\\r\\n geo_url = 'http://maps.google.com/maps/geo?key=%s&q=%s&sensor=false&output=csv'%(API_KEY,location)\\r\\n point = map(float,urlopen(geo_url).readline().split(',')[-2:])\\r\\n best,result = 99999999,[]\\r\\n for row in rows():\\r\\n test_point = map(float, (row[2],row[3]))\\r\\n distance = ((test_point[0]-point[0])**2 + (test_point[1]-point[1])**2)**.5\\r\\n if distance < best:\\r\\n best,result = distance,row\\r\\n return tuple(result)\",\n \"def get_location(geoname):\\n\\n DB_NAME = global_settings.DB_NAME_GEONAMES\\n db_user = global_settings.POSTGRESQL_USERNAME\\n db_password = global_settings.POSTGRESQL_PASSWORD\\n db_host = global_settings.POSTGRESQL_HOST\\n db_port = global_settings.POSTGRESQL_PORT\\n\\n sql = \\\"SELECT latitude, longitude FROM {} WHERE name like '{}'\\\".format(global_settings.TABLE_NAME_GEONAMES, geoname)\\n\\n resp = sqlExecute(DB_NAME, db_user, db_password, db_host, db_port, sql, True)\\n\\n if not resp['success']:\\n return []\\n\\n lat_long = []\\n\\n for data in resp['data']:\\n lat_long.append([data[0], data[1]])\\n\\n return lat_long\",\n \"def find_nn(self, city, list):\\n start_city = self.get_coordinates_from_city(city)\\n return min((euclidean_distance(start_city, self.get_coordinates_from_city(rest)), rest) for rest in\\n list)\",\n \"def mock_country_code_by_addr(self, ip_addr):\\r\\n ip_dict = {\\r\\n '1.0.0.0': 'CU',\\r\\n '2.0.0.0': 'IR',\\r\\n '3.0.0.0': 'SY',\\r\\n '4.0.0.0': 'SD',\\r\\n '5.0.0.0': 'AQ', # Antartica\\r\\n }\\r\\n return ip_dict.get(ip_addr, 'US')\",\n \"def getLocation(self, state, city, token):\\n d = requests.get(\\n 'http://api.wunderground.com/api/' + str(token) + '/forecast/q/' + str(state) + '/' + str(city) + '.json')\\n json = d.json()\\n return json\",\n \"def get_near_cities_from_user_coordinates(user_coordinates):\\n data = pandas.read_csv('city_coordinates.tsv', sep='\\\\t')\\n cities = data['city_ascii']\\n latitudes, longitudes = data['lat'], data['lng']\\n distance_list = []\\n for city, lat, lng in zip(cities, latitudes, longitudes):\\n try:\\n distance = geodesic((lat, lng), user_coordinates).km\\n distance_list.append(((lat, lng), city, distance))\\n except Exception:\\n continue\\n distance_list_sorted = sorted(distance_list, key=lambda x: x[-1])\\n return [elem[-2] for elem in distance_list_sorted[:100]]\",\n \"def get_cities(self, city_name: str = None):\",\n \"def city(self):\\n if \\\"city\\\" in self._prop_dict:\\n return self._prop_dict[\\\"city\\\"]\\n else:\\n return None\",\n \"def city(self):\\n if \\\"city\\\" in self._prop_dict:\\n return self._prop_dict[\\\"city\\\"]\\n else:\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68224823","0.6361756","0.615891","0.6116001","0.60422117","0.5858442","0.58064425","0.5731553","0.5635527","0.5595735","0.5581862","0.5567429","0.5552811","0.5550357","0.5547978","0.5525822","0.5514432","0.5505999","0.55029947","0.5498044","0.5496425","0.5496083","0.5491691","0.54786426","0.5463259","0.54490113","0.54308754","0.54259163","0.5420267","0.5419821","0.54055834","0.53882253","0.5368463","0.5343206","0.5341077","0.5312495","0.5303994","0.5259472","0.52563494","0.5238988","0.52320397","0.52153957","0.52081007","0.5200326","0.51983416","0.51979315","0.5190714","0.5188382","0.51785505","0.5159475","0.5155954","0.51534116","0.51460034","0.51407766","0.5134605","0.51317066","0.5130917","0.5111362","0.509316","0.5085773","0.5084377","0.5083924","0.50838226","0.5080977","0.5080977","0.50785077","0.5066489","0.5061412","0.50517124","0.5047672","0.5044735","0.5043586","0.50355667","0.50291437","0.50242895","0.50172323","0.5012122","0.50117975","0.50091475","0.5006324","0.5002882","0.5001863","0.49987957","0.4998771","0.4996645","0.49922967","0.49917504","0.4989567","0.49863335","0.49770853","0.4970432","0.4965338","0.49619108","0.49567798","0.49556682","0.49513566","0.49505806","0.49494293","0.4938947","0.4938947"],"string":"[\n \"0.68224823\",\n \"0.6361756\",\n \"0.615891\",\n \"0.6116001\",\n \"0.60422117\",\n \"0.5858442\",\n \"0.58064425\",\n \"0.5731553\",\n \"0.5635527\",\n \"0.5595735\",\n \"0.5581862\",\n \"0.5567429\",\n \"0.5552811\",\n \"0.5550357\",\n \"0.5547978\",\n \"0.5525822\",\n \"0.5514432\",\n \"0.5505999\",\n \"0.55029947\",\n \"0.5498044\",\n \"0.5496425\",\n \"0.5496083\",\n \"0.5491691\",\n \"0.54786426\",\n \"0.5463259\",\n \"0.54490113\",\n \"0.54308754\",\n \"0.54259163\",\n \"0.5420267\",\n \"0.5419821\",\n \"0.54055834\",\n \"0.53882253\",\n \"0.5368463\",\n \"0.5343206\",\n \"0.5341077\",\n \"0.5312495\",\n \"0.5303994\",\n \"0.5259472\",\n \"0.52563494\",\n \"0.5238988\",\n \"0.52320397\",\n \"0.52153957\",\n \"0.52081007\",\n \"0.5200326\",\n \"0.51983416\",\n \"0.51979315\",\n \"0.5190714\",\n \"0.5188382\",\n \"0.51785505\",\n \"0.5159475\",\n \"0.5155954\",\n \"0.51534116\",\n \"0.51460034\",\n \"0.51407766\",\n \"0.5134605\",\n \"0.51317066\",\n \"0.5130917\",\n \"0.5111362\",\n \"0.509316\",\n \"0.5085773\",\n \"0.5084377\",\n \"0.5083924\",\n \"0.50838226\",\n \"0.5080977\",\n \"0.5080977\",\n \"0.50785077\",\n \"0.5066489\",\n \"0.5061412\",\n \"0.50517124\",\n \"0.5047672\",\n \"0.5044735\",\n \"0.5043586\",\n \"0.50355667\",\n \"0.50291437\",\n \"0.50242895\",\n \"0.50172323\",\n \"0.5012122\",\n \"0.50117975\",\n \"0.50091475\",\n \"0.5006324\",\n \"0.5002882\",\n \"0.5001863\",\n \"0.49987957\",\n \"0.4998771\",\n \"0.4996645\",\n \"0.49922967\",\n \"0.49917504\",\n \"0.4989567\",\n \"0.49863335\",\n \"0.49770853\",\n \"0.4970432\",\n \"0.4965338\",\n \"0.49619108\",\n \"0.49567798\",\n \"0.49556682\",\n \"0.49513566\",\n \"0.49505806\",\n \"0.49494293\",\n \"0.4938947\",\n \"0.4938947\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79270655"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90996,"cells":{"query":{"kind":"string","value":"Run once, or forever, depending on config."},"document":{"kind":"string","value":"def run(self):\n if self.config.daemon():\n self.logger.info(\"Running forever, in a loop\")\n self.run_forever()\n else:\n self.logger.info(\"Running once, to completion\")\n self.run_once()"},"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 run_forever(self):\n while True:\n self.run_once()\n\n self.logger.info(f\"Sleeping for {self.config.sleep()} seconds\")\n time.sleep(self.config.sleep())","def run_forever(self):\n self.factory.manager.run_forever()","def _run_once(self):\n try:\n self.do_wait()\n self._execute_wakeup_tasks()\n self._trigger_timers()\n except Exception as e:\n Log.error(\"Error occured during _run_once(): \" + e.message)\n Log.error(traceback.format_exc())\n self.should_exit = True","def run_single(self):\n self.run_sim_time(1)","def run_forever(self):\n self.app.run()","def run_once(self, timeout=None): # NEW!\n self.app.update()","def run():\r\n autostartup()","def run_forever(self, cfg, sql):\n self.server = Server()\n self.server.run_forever(cfg, sql)","def loop(self):\n while not self.should_exit:\n self._run_once()\n\n self.on_exit()","def loop_forever(self):\n self.client.loop_forever()","def run(self):\n if not self.running:\n self.loop.run_forever()","def run_forever(self):\n self._loop.run_until_complete(self._loop_body())","def run(self):\n self.running = True\n dynamic_reconfigure.client.Client(\"dynamic_reconfigure_server\", timeout=5, config_callback=self.dynamic_reconfigure_callback)\n rate = rospy.Rate(20)\n while not rospy.is_shutdown() and self.running:\n self.pub.publish(self.get_cmd_vel())\n rate.sleep()","def run_forever(self):\n reactor.run()","def run_forever(self):\n reactor.run()","def loop_once(self):\n while 1:\n if not self._active_nodes:\n # If everything has died stop looping\n self.triggershutdown()\n raise RuntimeError(\"Unexpectedly no active workers available\")\n try:\n eventcall = self.queue.get(timeout=2.0)\n break\n except Empty:\n continue\n callname, kwargs = eventcall\n assert callname, kwargs\n method = \"worker_\" + callname\n call = getattr(self, method)\n self.log(\"calling method\", method, kwargs)\n call(**kwargs)\n if self.sched.tests_finished:\n self.triggershutdown()","def run():\r\n autostartup()\r\n\r\n if settings.FEATURES.get('USE_CUSTOM_THEME', False):\r\n enable_theme()\r\n\r\n if settings.FEATURES.get('USE_MICROSITES', False):\r\n enable_microsites()\r\n\r\n if settings.FEATURES.get('ENABLE_THIRD_PARTY_AUTH', False):\r\n enable_third_party_auth()","def run_forever(self):\n self.ws.run_forever()","def run(self):\n self.connect()\n self.run_forever()","def run_once(self):\r\n with self._run_lock:\r\n self.run(self._process_queue,True) # True: override flag for saving\r","def loop_forever(self):\n while self.running:\n time.sleep(0.01)","def run(self):\n # for running indefinitely if 'watch' is passed\n if self._arguments.watch:\n while True:\n self.watch(self.main(), int(self._arguments.watch))\n else:\n self.main()","def everytime(self):\n return True","def run(self):\n self.__server.serve_forever()","def run_forever(self):\n return self.gw.run()","def run_forever(self):\n asyncio.run(self._loop_body())","def AutonomousPeriodic(self):\n Scheduler.GetInstance().Run()","def run(self):\n if getattr(self, '_App__running', False):\n raise _tdl.TDLError('An App can not be run multiple times simultaneously')\n self.__running = True\n while self.__running:\n self.runOnce()","def loop_forever(self):\n self.running = True\n while self.running:\n time.sleep(0.1)","async def _main(self):\n while True:\n time.sleep(1)","def run_once(self):\n if not hasattr(self, '_App__prevTime'):\n self.__prevTime = _time.clock() # initiate __prevTime\n for event in get():\n if event.type: # exclude custom events with a blank type variable\n # call the ev_* methods\n method = 'ev_%s' % event.type # ev_TYPE\n getattr(self, method)(event)\n if event.type == 'KEYDOWN':\n # call the key_* methods\n method = 'key_%s' % event.key # key_KEYNAME\n if hasattr(self, method): # silently exclude undefined methods\n getattr(self, method)(event)\n newTime = _time.clock()\n self.update(newTime - self.__prevTime)\n self.__prevTime = newTime\n #_tdl.flush()","def run():\n server = current_server()\n server._auto_stop = True\n return start()","def run():\n jekyll('serve --watch')","def run(self):\n while True:\n self.current_wifi_clients()\n self._eval_is_someone_home()\n time.sleep(self._interval)","def run_once(self):\n\n if self.tenant_id not in RUNTIME.tenants:\n return\n\n lvaps = RUNTIME.tenants[self.tenant_id].lvaps\n\n if self.lvap not in lvaps:\n return\n\n lvap = lvaps[self.lvap]\n\n if not lvap.wtp.connection:\n return\n\n self.send_rates_request(lvap.wtp, lvap)","def Listen(self):\n while True:\n time.sleep(1)","def run(self):\n rate = rospy.Rate(self._run_rate)\n while not rospy.is_shutdown():\n try:\n rate.sleep()\n except:\n break","def run(self):\n r = rospy.Rate(100)\n while not rospy.is_shutdown():\n r.sleep()","def main(config):\n\n runModel(config)\n while (config['looping']):\n runModel(config)","def run(self):\n #=======================================================================\n #\n # TODO: Replace this do-nothing code with some which does something.\n # Don't worry about looping (though you can), since this will be called\n # over and over again by the main appliance loop.\n #\n #=======================================================================\n self.logger.info('Nothing to do; sleeping for a while.')\n sleep(10)\n\n # Return something truthy to continue, anything else to exit.\n return True","def main():\n\tconnected = False\n\t# Get the values from the config file\n\tconfig = read_config()\n\t# Do the infinite(ish) internet check loop\n\twhile True:\n\t\tconnected = check_connection(connected, config)\n\t\ttime.sleep(30)","def start(self):\n self.serve_forever()","def start(self):\n self.serve_forever()","def run(self):\n self._server = self._get_server()\n self._server.serve_forever()","def run_forever(self, accounts_count: int):\n\n print( Fore.BLUE + ':: Watching Session Files ... ::' )\n self.reload_sessions()\n\n print( Fore.BLUE + ':: Reloading Accuonts Info ... ::' )\n self.reload_info()\n\n self.start(accounts_count)\n\n print( Fore.YELLOW + ':: Started Handlers (Running forever) ::' )\n self.block()","def run(self, reset_on_stop=True):\n\n if self.running:\n raise RuntimeError(\"EventLoop is already running.\")\n else:\n self.reset()\n self.running = True\n \n while self.running: #self._shouldRun(0):\n try:\n self.runOnce()\n except Exception, e:\n self.handleException(e)\n\n if reset_on_stop: \n self.reset()","def run(self):\r\n self.rpc_server.serve_forever(0.5)","def serve_forever(self):\n self._server.serve_forever()","def run_once(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n if not wrapper.has_run:\n result = func(*args, **kwargs)\n wrapper.has_run = True\n return result\n wrapper.has_run = False\n return wrapper","def monitor(self):\n if self.startup():\n time.sleep(0.250)\n self.run()","def work(self):\n self.config_file = self.args.config\n self.init_config()\n self.init_db()\n\n self.kickoff()","def run(self):\n self._keep_running()","async def async_run_forever(self):\n raise NotImplementedError","def run():\r\n log.debug('Starter::run()')\r\n try:\r\n # check specified port\r\n if not conf.port:\r\n raise Exception(\"Please specify port number! (use --port)\")\r\n Server(conf.port).run()\r\n except Exception as E:\r\n log.critical(E)","def RunOnce(client, job, callback):\n today = util.NowUTCToISO8601()\n\n last_run = yield gen.Task(job.FindLastSuccess, with_payload_key='stats.last_day')\n if last_run is not None and last_run['stats.last_day'] == today and not options.options.force_recompute:\n logging.info('Already ran successfully today: skipping. Specify --force_recompute to recompute.')\n callback(None)\n return\n\n # Analyze.\n day_stats = yield gen.Task(ProcessTables, client)\n assert day_stats is not None\n\n # Write per-day stats to dynamodb.\n hms = logs_util.kDailyMetricsTimeByLogType['dynamodb_user']\n yield gen.Task(logs_util.UpdateMetrics, client, {today: day_stats}, dry_run=options.options.dry_run, hms_tuple=hms,\n prefix_to_erase='dynamodb.user')\n callback(today)","def run(config: AppConfig) -> int:\r\n logging.info(\"starting\")\r\n es = Elasticsearch(hosts=[\"{}:{}\".format(config.es_host, config.es_port)])\r\n es.indices.create(index=config.es_index, ignore=400)\r\n\r\n while True:\r\n time.sleep(config.pub_intvl)\r\n rc, hum_rh, temp_c, ts = read_sensor(config.sensor, config.gpio_pin)\r\n if rc != 0:\r\n logging.error(\"failed to read from sensor\")\r\n continue\r\n sensor_data = SensorReading(hum_rh=hum_rh, temp_c=temp_c, timestamp=ts,\r\n location=config.doc_tag)\r\n publish_data(es, config.es_index, sensor_data)\r\n\r\n return 0","def run(self):\n while True:\n try:\n sleep(influx_settings.write_freq)\n self._redis2influx()\n except InterruptExceptions as ex:\n raise ex","def _run(self):\n while(self._loop):\n pass","def run(self): \n #\n\n \n # forever loop\n while True: \n \n for app in self.app_list:\n self.check(app) \n #print(\"check\")\n \n gevent.sleep(SLEEP_SECONDS)","def run_one_step(self):\n pass","def start(self):\n threading.Thread(target=self.serve_forever).start()","def playbook_on_start(this):\n\n # Monkey-patch ansible.playbook.task.Task\n import ansible.playbook.task\n\n class T(ansible.playbook.task.Task):\n VALID_KEYS = ansible.playbook.task.Task.VALID_KEYS.union({'run_once_per'})\n\n def __init__(self, play, ds, **kwargs):\n super(T, self).__init__(play, ds, **kwargs)\n self.run_once_per = ds.get('run_once_per')\n\n ansible.playbook.task.Task = T\n\n # We'll need to get ansible.playbook.play.Task too\n import ansible.playbook.play\n ansible.playbook.play.Task = T\n\n # Monkey-patch ansible.runner.Runner.run\n import ansible.runner\n\n old_run = ansible.runner.Runner.run\n def run(self):\n # Work out the hosts to run on.\n if this.task is None or this.task.run_once_per is None:\n return old_run(self)\n\n per_expr = \"{{\" + this.task.run_once_per + \"}}\"\n\n # Evaluate that expression per current host.\n groups = collections.defaultdict(list)\n\n if not self.run_hosts:\n self.run_hosts = self.inventory.list_hosts(self.pattern)\n hosts = self.run_hosts\n\n if len(hosts) == 0:\n return old_run(self)\n\n for host in hosts:\n inject = self.get_inject_vars(host)\n value = template.template(self.basedir, per_expr, inject, fail_on_undefined=True)\n vvv(\"evaluating {} for {} and got {!r}\".format(per_expr, host, value))\n groups[value].append(host)\n\n vv(\"run_once_per for each of {!r}\".format(groups))\n try:\n self.run_hosts = [groups[value][0] for value in groups]\n return old_run(self)\n finally:\n self.run_hosts = hosts\n\n ansible.runner.Runner.run = run","def run_while_true(server_class=BaseHTTPServer.HTTPServer,\n handler_class=BaseHTTPServer.BaseHTTPRequestHandler):\n server_address = ('localhost', 8080)\n httpd = server_class(server_address, handler_class)\n while keep_running():\n httpd.handle_request()","def run(self):\n while True:\n req = self._requests.get()[1]\n req.start()\n logging.info('Running request %s', req)","def run_once(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n if not wrapper.has_run:\n result = f(*args, **kwargs)\n wrapper.has_run = True\n wrapper.result = result\n \n return wrapper.result\n \n wrapper.has_run = False\n return wrapper","def run(self):\n while not self.stop_event.is_set():\n self.manage_cache_tasks()","def main() -> None:\n runner()\n asyncio.get_event_loop().run_forever()","def main() -> None:\n runner()\n asyncio.get_event_loop().run_forever()","def startScrape(latest=False):\n print '*** STARTED SCRAPING: DEFAULT: ***' \n cache.set('default_scrape','true')\n cache.set('scrape_mode','default')\n \n for key in ['scrape_friends','scrape_followers','scrape_tweets']:\n cache.set(key,'')\n \n doDefaultScrape.delay(latest=latest)","def run_at_time_once(self, time_info):\n # if lead and either init or valid are set, compute other string sub\n if time_info.get('lead') != '*':\n if (time_info.get('init') != '*'\n or time_info.get('valid') != '*'):\n time_info = time_util.ti_calculate(time_info)\n\n # create file list text files for the current run time criteria\n # set c_dict to the input file dict to set as environment vars\n self.c_dict['INPUT_LIST_DICT'] = self.subset_input_files(time_info)\n\n self.set_environment_variables(time_info)\n\n # substitute values from dictionary into command\n self.c_dict['COMMAND'] = (\n do_string_sub(self.c_dict['COMMAND_TEMPLATE'],\n **time_info)\n )\n\n return self.build()","def run(self): # pragma: no cover\n while True:\n self.update()","def run(self):\n last_time = time.time()\n while self.running:\n now_time = time.time()\n interval = now_time - last_time\n last_time = now_time\n self.update(interval)\n time.sleep(Options['update interval'])","def listen(config: dict):\n\n async def state_callback(self):\n\n self.shared_state[\"callback_counter\"] += 1\n\n if self.basic_info is not None:\n print_device_details(self)\n\n if self.shared_state[\"callback_counter\"] == 0: # pragma: no cover\n logger.info(\n \"Listening for updates forever...' \\\n 'Press CTRL+C to quit.\"\n )\n else:\n if config[\"wait\"] is not None:\n if self.shared_state[\"callback_counter\"] >= int(\n config[\"wait\"]\n ):\n self.shutdown_event_loop()\n\n logger.info(\"Initialising SonoffSwitch with host %s\" % config[\"host\"])\n\n shared_state = {\"callback_counter\": 0}\n SonoffSwitch(\n host=config[\"host\"],\n callback_after_update=state_callback,\n shared_state=shared_state,\n logger=logger,\n device_id=config[\"device_id\"],\n api_key=config[\"api_key\"],\n )","def _event_loop(self):\n while True:\n self.scheduler.run(blocking=True)\n time.sleep(1)","def run(self):\n while True:\n self.sm.run()\n time.sleep(0.05)","def console_server(request):\n return run_server(interval='1')","def infinite_loop():\n return True","def every_day(self, time, function, args=None, kwargs=None, name=None):\n if args is None:\n args = list()\n if kwargs is None:\n kwargs = dict()\n if name is None:\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\n self.config[name] = {'mode':'every_day', 'time':time, 'function':function, 'args':args, \n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\n 'time_init':datetime.datetime.now()}\n self.params.tracker_dict[name] = dict()","def _main():\n parser = _create_parser()\n args = parser.parse_args()\n\n if args.interval is None:\n args.interval = 10\n\n if args.what_if is None:\n args.what_if = False\n\n loop = asyncio.get_event_loop()\n\n params = {\n \"connection_string\": args.connection_string,\n \"name\": args.name,\n \"interval\": args.interval,\n \"what_if\": args.what_if\n }\n\n loop.run_until_complete(_run(params))","def run(self):\n try:\n while self._running:\n time.sleep(1)\n finally:\n self._exit()","def run(self):\n while self.running:\n self.handle_request()","def run(self):\n\t\t\n\t\twhile self.update():\n\t\t\tpass","def _loop(self):\n while True:\n if GameLoop.getInstance()._cancelation_token==True:\n break\n self._update_signal.notify_all()\n sleep(1/60)","def sleep_for_cloudinit():\n run(\"sleep 15\")","def loop(self):\n pass","def run(self):\n while True:\n # Do something\n print('Doing something imporant in the background')\n\n self.loadData()\n time.sleep(self.interval)","def run(self):\n while True:\n print(\"I'm running in the background\")\n time.sleep(self.interval)","def scan(self):\n\n from urllib3.exceptions import MaxRetryError, NewConnectionError\n #While we haven't successfully run\n while True:\n try:\n #Try to run\n self.run()\n break\n except:\n #Otherwise restart\n sys.exit()\n #self.restart()\n time.sleep(10)","def main_loop(self) -> None:\n while True:\n # Log a message to say that Wheatley is waiting for 'Look To!'\n self.logger.info(\"Waiting for 'Look To!'...\")\n # Sit in an infinite loop whilst we're not ringing, and exit Wheatley if enough time\n # has passed\n self._last_activity_time = time.time()\n while not self._is_ringing:\n time.sleep(0.01)\n if self._server_mode and time.time() > self._last_activity_time + INACTIVITY_EXIT_TIME:\n self.logger.info(f\"Timed out - no activity for {INACTIVITY_EXIT_TIME}s. Exiting.\")\n return\n\n self.logger.info(f\"Starting to ring {self.row_generator.summary_string()}\")\n if self._server_mode:\n self._tower.set_is_ringing(True)\n\n while self._is_ringing:\n self.tick()\n time.sleep(0.01)\n\n self.logger.info(\"Stopping ringing!\")\n if self._server_mode:\n self._tower.set_is_ringing(False)","def run_forever(func):\n def forever_wrapped():\n waittime = 1.\n lastwait = time.time()\n while True:\n try:\n func()\n except KeyboardInterrupt: # we allow user to interrupt us ;-\n print(\"User abort\")\n return\n except IOError as ioe:\n print(\"Connection was closed: %s\" % str(ioe))\n except IncompleteRead as ire:\n print(\"Twitter sending us shit: %s\" % str(ire))\n except RuntimeError as re:\n print(\"Problem during this run: %s\" % str(re))\n except BaseException as e:\n traceback.print_exception(type(e), e, sys.exc_info()[2])\n else:\n print(\"Terminated... \", end=\"\")\n\n now = time.time()\n # reset waittime when we ran for at least 10 minute without issues\n if lastwait + waittime + 600 < now:\n waittime = 1.\n lastwait = now\n\n print(\"Restarting in %.0f seconds\" % waittime)\n signal.alarm(0) # reset watchdog here :-/\n time.sleep(waittime)\n\n # max wait time is 20min\n waittime = min(20 * 60, waittime * 2) # exponential backoff\n return forever_wrapped","def run(self):\n print \"running presence detection\"\n r = rospy.Rate(10)\n time.sleep(2)\n\n while not rospy.is_shutdown():\n if self.running:\n self.find_new_people()\n self.follow_people()\n\n r.sleep()","def dynamic_discovery(self):\n while True:\n sleep(DYNAMIC_DISCOVERY_SLEEP)\n logging.debug(\"Starting Dynamic Discovery!\")\n self.datastream_discovery()","def run(self):\n try:\n self.eventloop.run_forever()\n except KeyboardInterrupt:\n self.logger.info(\"Interrupt received, shutting down.\")\n except Exception:\n self.logger.exception(\"Unhandled exception raised, shutting down.\")\n finally:\n self._shutdown()\n self.logger.debug(\"Closing event loop\")\n self.eventloop.close()\n if self._restarting:\n self.logger.info(f\"Restarting with command line: {sys.argv}\")\n os.execl(sys.executable, sys.executable, *sys.argv)","def _run(self):\n #print(\"try to connect run\")\n while True:\n self._connect()\n while not self.connected and self.auto_retry is not None:\n gevent.sleep(self.auto_retry)\n self._connect()\n if self.connected:\n self.run()\n if self.auto_retry is None:\n break","def run():\n main()","def run(self, forever=False, interval=300):\n\n bot_start_time = time.time()\n\n while True:\n try:\n self.process_posts()\n except Exception as e:\n logging.exception(\"bot:run\")\n rollbar.report_exc_info()\n\n if not forever:\n break\n\n sleep_interval = float(interval) - ((time.time() - bot_start_time) % float(interval))\n\n logging.info(\"Sleeping for {0} seconds until next run.\".format(sleep_interval))\n time.sleep(sleep_interval)","def run_cron(self):\n logging.info(\n 'Starting with the \"cron\" parameter, we will run once and then exit.'\n )\n self.request_messages()\n logging.info(\"Nothing more to be done, we will exit.\")\n exit(0)","def run():\n REDIRECT = False\n LOG_FILE = \"truss.log\"\n app = App(REDIRECT)\n app.MainLoop()","def main():\n populate_satellites_array()\n latitude = float(os.environ['LATITUDE'])\n longitude = float(os.environ['LONGITUDE'])\n radius = int(os.environ['RADIUS'])\n timeout = 1\n previous_satellites = []\n while True:\n if (last_updated[0] + 86400) < int(time.time()):\n print('Expired data, updating from spacetrack')\n cron_refresh_spacetrack_cache()\n populate_satellites_array()\n print('Checking {}, {}'.format(latitude, longitude))\n currently_overhead = get_overhead_satellites_dicts(latitude, longitude, radius)\n for sat in currently_overhead:\n if not sat['name'] in previous_satellites:\n announce_satellite(sat)\n previous_satellites = [x['name'] for x in currently_overhead]\n time.sleep(timeout)","def entry(self):\n if not os.path.isfile('model'):\n train()\n schedule.every(0.01).seconds.do(predict, self)\n while True:\n schedule.run_pending()"],"string":"[\n \"def run_forever(self):\\n while True:\\n self.run_once()\\n\\n self.logger.info(f\\\"Sleeping for {self.config.sleep()} seconds\\\")\\n time.sleep(self.config.sleep())\",\n \"def run_forever(self):\\n self.factory.manager.run_forever()\",\n \"def _run_once(self):\\n try:\\n self.do_wait()\\n self._execute_wakeup_tasks()\\n self._trigger_timers()\\n except Exception as e:\\n Log.error(\\\"Error occured during _run_once(): \\\" + e.message)\\n Log.error(traceback.format_exc())\\n self.should_exit = True\",\n \"def run_single(self):\\n self.run_sim_time(1)\",\n \"def run_forever(self):\\n self.app.run()\",\n \"def run_once(self, timeout=None): # NEW!\\n self.app.update()\",\n \"def run():\\r\\n autostartup()\",\n \"def run_forever(self, cfg, sql):\\n self.server = Server()\\n self.server.run_forever(cfg, sql)\",\n \"def loop(self):\\n while not self.should_exit:\\n self._run_once()\\n\\n self.on_exit()\",\n \"def loop_forever(self):\\n self.client.loop_forever()\",\n \"def run(self):\\n if not self.running:\\n self.loop.run_forever()\",\n \"def run_forever(self):\\n self._loop.run_until_complete(self._loop_body())\",\n \"def run(self):\\n self.running = True\\n dynamic_reconfigure.client.Client(\\\"dynamic_reconfigure_server\\\", timeout=5, config_callback=self.dynamic_reconfigure_callback)\\n rate = rospy.Rate(20)\\n while not rospy.is_shutdown() and self.running:\\n self.pub.publish(self.get_cmd_vel())\\n rate.sleep()\",\n \"def run_forever(self):\\n reactor.run()\",\n \"def run_forever(self):\\n reactor.run()\",\n \"def loop_once(self):\\n while 1:\\n if not self._active_nodes:\\n # If everything has died stop looping\\n self.triggershutdown()\\n raise RuntimeError(\\\"Unexpectedly no active workers available\\\")\\n try:\\n eventcall = self.queue.get(timeout=2.0)\\n break\\n except Empty:\\n continue\\n callname, kwargs = eventcall\\n assert callname, kwargs\\n method = \\\"worker_\\\" + callname\\n call = getattr(self, method)\\n self.log(\\\"calling method\\\", method, kwargs)\\n call(**kwargs)\\n if self.sched.tests_finished:\\n self.triggershutdown()\",\n \"def run():\\r\\n autostartup()\\r\\n\\r\\n if settings.FEATURES.get('USE_CUSTOM_THEME', False):\\r\\n enable_theme()\\r\\n\\r\\n if settings.FEATURES.get('USE_MICROSITES', False):\\r\\n enable_microsites()\\r\\n\\r\\n if settings.FEATURES.get('ENABLE_THIRD_PARTY_AUTH', False):\\r\\n enable_third_party_auth()\",\n \"def run_forever(self):\\n self.ws.run_forever()\",\n \"def run(self):\\n self.connect()\\n self.run_forever()\",\n \"def run_once(self):\\r\\n with self._run_lock:\\r\\n self.run(self._process_queue,True) # True: override flag for saving\\r\",\n \"def loop_forever(self):\\n while self.running:\\n time.sleep(0.01)\",\n \"def run(self):\\n # for running indefinitely if 'watch' is passed\\n if self._arguments.watch:\\n while True:\\n self.watch(self.main(), int(self._arguments.watch))\\n else:\\n self.main()\",\n \"def everytime(self):\\n return True\",\n \"def run(self):\\n self.__server.serve_forever()\",\n \"def run_forever(self):\\n return self.gw.run()\",\n \"def run_forever(self):\\n asyncio.run(self._loop_body())\",\n \"def AutonomousPeriodic(self):\\n Scheduler.GetInstance().Run()\",\n \"def run(self):\\n if getattr(self, '_App__running', False):\\n raise _tdl.TDLError('An App can not be run multiple times simultaneously')\\n self.__running = True\\n while self.__running:\\n self.runOnce()\",\n \"def loop_forever(self):\\n self.running = True\\n while self.running:\\n time.sleep(0.1)\",\n \"async def _main(self):\\n while True:\\n time.sleep(1)\",\n \"def run_once(self):\\n if not hasattr(self, '_App__prevTime'):\\n self.__prevTime = _time.clock() # initiate __prevTime\\n for event in get():\\n if event.type: # exclude custom events with a blank type variable\\n # call the ev_* methods\\n method = 'ev_%s' % event.type # ev_TYPE\\n getattr(self, method)(event)\\n if event.type == 'KEYDOWN':\\n # call the key_* methods\\n method = 'key_%s' % event.key # key_KEYNAME\\n if hasattr(self, method): # silently exclude undefined methods\\n getattr(self, method)(event)\\n newTime = _time.clock()\\n self.update(newTime - self.__prevTime)\\n self.__prevTime = newTime\\n #_tdl.flush()\",\n \"def run():\\n server = current_server()\\n server._auto_stop = True\\n return start()\",\n \"def run():\\n jekyll('serve --watch')\",\n \"def run(self):\\n while True:\\n self.current_wifi_clients()\\n self._eval_is_someone_home()\\n time.sleep(self._interval)\",\n \"def run_once(self):\\n\\n if self.tenant_id not in RUNTIME.tenants:\\n return\\n\\n lvaps = RUNTIME.tenants[self.tenant_id].lvaps\\n\\n if self.lvap not in lvaps:\\n return\\n\\n lvap = lvaps[self.lvap]\\n\\n if not lvap.wtp.connection:\\n return\\n\\n self.send_rates_request(lvap.wtp, lvap)\",\n \"def Listen(self):\\n while True:\\n time.sleep(1)\",\n \"def run(self):\\n rate = rospy.Rate(self._run_rate)\\n while not rospy.is_shutdown():\\n try:\\n rate.sleep()\\n except:\\n break\",\n \"def run(self):\\n r = rospy.Rate(100)\\n while not rospy.is_shutdown():\\n r.sleep()\",\n \"def main(config):\\n\\n runModel(config)\\n while (config['looping']):\\n runModel(config)\",\n \"def run(self):\\n #=======================================================================\\n #\\n # TODO: Replace this do-nothing code with some which does something.\\n # Don't worry about looping (though you can), since this will be called\\n # over and over again by the main appliance loop.\\n #\\n #=======================================================================\\n self.logger.info('Nothing to do; sleeping for a while.')\\n sleep(10)\\n\\n # Return something truthy to continue, anything else to exit.\\n return True\",\n \"def main():\\n\\tconnected = False\\n\\t# Get the values from the config file\\n\\tconfig = read_config()\\n\\t# Do the infinite(ish) internet check loop\\n\\twhile True:\\n\\t\\tconnected = check_connection(connected, config)\\n\\t\\ttime.sleep(30)\",\n \"def start(self):\\n self.serve_forever()\",\n \"def start(self):\\n self.serve_forever()\",\n \"def run(self):\\n self._server = self._get_server()\\n self._server.serve_forever()\",\n \"def run_forever(self, accounts_count: int):\\n\\n print( Fore.BLUE + ':: Watching Session Files ... ::' )\\n self.reload_sessions()\\n\\n print( Fore.BLUE + ':: Reloading Accuonts Info ... ::' )\\n self.reload_info()\\n\\n self.start(accounts_count)\\n\\n print( Fore.YELLOW + ':: Started Handlers (Running forever) ::' )\\n self.block()\",\n \"def run(self, reset_on_stop=True):\\n\\n if self.running:\\n raise RuntimeError(\\\"EventLoop is already running.\\\")\\n else:\\n self.reset()\\n self.running = True\\n \\n while self.running: #self._shouldRun(0):\\n try:\\n self.runOnce()\\n except Exception, e:\\n self.handleException(e)\\n\\n if reset_on_stop: \\n self.reset()\",\n \"def run(self):\\r\\n self.rpc_server.serve_forever(0.5)\",\n \"def serve_forever(self):\\n self._server.serve_forever()\",\n \"def run_once(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n if not wrapper.has_run:\\n result = func(*args, **kwargs)\\n wrapper.has_run = True\\n return result\\n wrapper.has_run = False\\n return wrapper\",\n \"def monitor(self):\\n if self.startup():\\n time.sleep(0.250)\\n self.run()\",\n \"def work(self):\\n self.config_file = self.args.config\\n self.init_config()\\n self.init_db()\\n\\n self.kickoff()\",\n \"def run(self):\\n self._keep_running()\",\n \"async def async_run_forever(self):\\n raise NotImplementedError\",\n \"def run():\\r\\n log.debug('Starter::run()')\\r\\n try:\\r\\n # check specified port\\r\\n if not conf.port:\\r\\n raise Exception(\\\"Please specify port number! (use --port)\\\")\\r\\n Server(conf.port).run()\\r\\n except Exception as E:\\r\\n log.critical(E)\",\n \"def RunOnce(client, job, callback):\\n today = util.NowUTCToISO8601()\\n\\n last_run = yield gen.Task(job.FindLastSuccess, with_payload_key='stats.last_day')\\n if last_run is not None and last_run['stats.last_day'] == today and not options.options.force_recompute:\\n logging.info('Already ran successfully today: skipping. Specify --force_recompute to recompute.')\\n callback(None)\\n return\\n\\n # Analyze.\\n day_stats = yield gen.Task(ProcessTables, client)\\n assert day_stats is not None\\n\\n # Write per-day stats to dynamodb.\\n hms = logs_util.kDailyMetricsTimeByLogType['dynamodb_user']\\n yield gen.Task(logs_util.UpdateMetrics, client, {today: day_stats}, dry_run=options.options.dry_run, hms_tuple=hms,\\n prefix_to_erase='dynamodb.user')\\n callback(today)\",\n \"def run(config: AppConfig) -> int:\\r\\n logging.info(\\\"starting\\\")\\r\\n es = Elasticsearch(hosts=[\\\"{}:{}\\\".format(config.es_host, config.es_port)])\\r\\n es.indices.create(index=config.es_index, ignore=400)\\r\\n\\r\\n while True:\\r\\n time.sleep(config.pub_intvl)\\r\\n rc, hum_rh, temp_c, ts = read_sensor(config.sensor, config.gpio_pin)\\r\\n if rc != 0:\\r\\n logging.error(\\\"failed to read from sensor\\\")\\r\\n continue\\r\\n sensor_data = SensorReading(hum_rh=hum_rh, temp_c=temp_c, timestamp=ts,\\r\\n location=config.doc_tag)\\r\\n publish_data(es, config.es_index, sensor_data)\\r\\n\\r\\n return 0\",\n \"def run(self):\\n while True:\\n try:\\n sleep(influx_settings.write_freq)\\n self._redis2influx()\\n except InterruptExceptions as ex:\\n raise ex\",\n \"def _run(self):\\n while(self._loop):\\n pass\",\n \"def run(self): \\n #\\n\\n \\n # forever loop\\n while True: \\n \\n for app in self.app_list:\\n self.check(app) \\n #print(\\\"check\\\")\\n \\n gevent.sleep(SLEEP_SECONDS)\",\n \"def run_one_step(self):\\n pass\",\n \"def start(self):\\n threading.Thread(target=self.serve_forever).start()\",\n \"def playbook_on_start(this):\\n\\n # Monkey-patch ansible.playbook.task.Task\\n import ansible.playbook.task\\n\\n class T(ansible.playbook.task.Task):\\n VALID_KEYS = ansible.playbook.task.Task.VALID_KEYS.union({'run_once_per'})\\n\\n def __init__(self, play, ds, **kwargs):\\n super(T, self).__init__(play, ds, **kwargs)\\n self.run_once_per = ds.get('run_once_per')\\n\\n ansible.playbook.task.Task = T\\n\\n # We'll need to get ansible.playbook.play.Task too\\n import ansible.playbook.play\\n ansible.playbook.play.Task = T\\n\\n # Monkey-patch ansible.runner.Runner.run\\n import ansible.runner\\n\\n old_run = ansible.runner.Runner.run\\n def run(self):\\n # Work out the hosts to run on.\\n if this.task is None or this.task.run_once_per is None:\\n return old_run(self)\\n\\n per_expr = \\\"{{\\\" + this.task.run_once_per + \\\"}}\\\"\\n\\n # Evaluate that expression per current host.\\n groups = collections.defaultdict(list)\\n\\n if not self.run_hosts:\\n self.run_hosts = self.inventory.list_hosts(self.pattern)\\n hosts = self.run_hosts\\n\\n if len(hosts) == 0:\\n return old_run(self)\\n\\n for host in hosts:\\n inject = self.get_inject_vars(host)\\n value = template.template(self.basedir, per_expr, inject, fail_on_undefined=True)\\n vvv(\\\"evaluating {} for {} and got {!r}\\\".format(per_expr, host, value))\\n groups[value].append(host)\\n\\n vv(\\\"run_once_per for each of {!r}\\\".format(groups))\\n try:\\n self.run_hosts = [groups[value][0] for value in groups]\\n return old_run(self)\\n finally:\\n self.run_hosts = hosts\\n\\n ansible.runner.Runner.run = run\",\n \"def run_while_true(server_class=BaseHTTPServer.HTTPServer,\\n handler_class=BaseHTTPServer.BaseHTTPRequestHandler):\\n server_address = ('localhost', 8080)\\n httpd = server_class(server_address, handler_class)\\n while keep_running():\\n httpd.handle_request()\",\n \"def run(self):\\n while True:\\n req = self._requests.get()[1]\\n req.start()\\n logging.info('Running request %s', req)\",\n \"def run_once(f):\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n if not wrapper.has_run:\\n result = f(*args, **kwargs)\\n wrapper.has_run = True\\n wrapper.result = result\\n \\n return wrapper.result\\n \\n wrapper.has_run = False\\n return wrapper\",\n \"def run(self):\\n while not self.stop_event.is_set():\\n self.manage_cache_tasks()\",\n \"def main() -> None:\\n runner()\\n asyncio.get_event_loop().run_forever()\",\n \"def main() -> None:\\n runner()\\n asyncio.get_event_loop().run_forever()\",\n \"def startScrape(latest=False):\\n print '*** STARTED SCRAPING: DEFAULT: ***' \\n cache.set('default_scrape','true')\\n cache.set('scrape_mode','default')\\n \\n for key in ['scrape_friends','scrape_followers','scrape_tweets']:\\n cache.set(key,'')\\n \\n doDefaultScrape.delay(latest=latest)\",\n \"def run_at_time_once(self, time_info):\\n # if lead and either init or valid are set, compute other string sub\\n if time_info.get('lead') != '*':\\n if (time_info.get('init') != '*'\\n or time_info.get('valid') != '*'):\\n time_info = time_util.ti_calculate(time_info)\\n\\n # create file list text files for the current run time criteria\\n # set c_dict to the input file dict to set as environment vars\\n self.c_dict['INPUT_LIST_DICT'] = self.subset_input_files(time_info)\\n\\n self.set_environment_variables(time_info)\\n\\n # substitute values from dictionary into command\\n self.c_dict['COMMAND'] = (\\n do_string_sub(self.c_dict['COMMAND_TEMPLATE'],\\n **time_info)\\n )\\n\\n return self.build()\",\n \"def run(self): # pragma: no cover\\n while True:\\n self.update()\",\n \"def run(self):\\n last_time = time.time()\\n while self.running:\\n now_time = time.time()\\n interval = now_time - last_time\\n last_time = now_time\\n self.update(interval)\\n time.sleep(Options['update interval'])\",\n \"def listen(config: dict):\\n\\n async def state_callback(self):\\n\\n self.shared_state[\\\"callback_counter\\\"] += 1\\n\\n if self.basic_info is not None:\\n print_device_details(self)\\n\\n if self.shared_state[\\\"callback_counter\\\"] == 0: # pragma: no cover\\n logger.info(\\n \\\"Listening for updates forever...' \\\\\\n 'Press CTRL+C to quit.\\\"\\n )\\n else:\\n if config[\\\"wait\\\"] is not None:\\n if self.shared_state[\\\"callback_counter\\\"] >= int(\\n config[\\\"wait\\\"]\\n ):\\n self.shutdown_event_loop()\\n\\n logger.info(\\\"Initialising SonoffSwitch with host %s\\\" % config[\\\"host\\\"])\\n\\n shared_state = {\\\"callback_counter\\\": 0}\\n SonoffSwitch(\\n host=config[\\\"host\\\"],\\n callback_after_update=state_callback,\\n shared_state=shared_state,\\n logger=logger,\\n device_id=config[\\\"device_id\\\"],\\n api_key=config[\\\"api_key\\\"],\\n )\",\n \"def _event_loop(self):\\n while True:\\n self.scheduler.run(blocking=True)\\n time.sleep(1)\",\n \"def run(self):\\n while True:\\n self.sm.run()\\n time.sleep(0.05)\",\n \"def console_server(request):\\n return run_server(interval='1')\",\n \"def infinite_loop():\\n return True\",\n \"def every_day(self, time, function, args=None, kwargs=None, name=None):\\n if args is None:\\n args = list()\\n if kwargs is None:\\n kwargs = dict()\\n if name is None:\\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\\n self.config[name] = {'mode':'every_day', 'time':time, 'function':function, 'args':args, \\n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\\n 'time_init':datetime.datetime.now()}\\n self.params.tracker_dict[name] = dict()\",\n \"def _main():\\n parser = _create_parser()\\n args = parser.parse_args()\\n\\n if args.interval is None:\\n args.interval = 10\\n\\n if args.what_if is None:\\n args.what_if = False\\n\\n loop = asyncio.get_event_loop()\\n\\n params = {\\n \\\"connection_string\\\": args.connection_string,\\n \\\"name\\\": args.name,\\n \\\"interval\\\": args.interval,\\n \\\"what_if\\\": args.what_if\\n }\\n\\n loop.run_until_complete(_run(params))\",\n \"def run(self):\\n try:\\n while self._running:\\n time.sleep(1)\\n finally:\\n self._exit()\",\n \"def run(self):\\n while self.running:\\n self.handle_request()\",\n \"def run(self):\\n\\t\\t\\n\\t\\twhile self.update():\\n\\t\\t\\tpass\",\n \"def _loop(self):\\n while True:\\n if GameLoop.getInstance()._cancelation_token==True:\\n break\\n self._update_signal.notify_all()\\n sleep(1/60)\",\n \"def sleep_for_cloudinit():\\n run(\\\"sleep 15\\\")\",\n \"def loop(self):\\n pass\",\n \"def run(self):\\n while True:\\n # Do something\\n print('Doing something imporant in the background')\\n\\n self.loadData()\\n time.sleep(self.interval)\",\n \"def run(self):\\n while True:\\n print(\\\"I'm running in the background\\\")\\n time.sleep(self.interval)\",\n \"def scan(self):\\n\\n from urllib3.exceptions import MaxRetryError, NewConnectionError\\n #While we haven't successfully run\\n while True:\\n try:\\n #Try to run\\n self.run()\\n break\\n except:\\n #Otherwise restart\\n sys.exit()\\n #self.restart()\\n time.sleep(10)\",\n \"def main_loop(self) -> None:\\n while True:\\n # Log a message to say that Wheatley is waiting for 'Look To!'\\n self.logger.info(\\\"Waiting for 'Look To!'...\\\")\\n # Sit in an infinite loop whilst we're not ringing, and exit Wheatley if enough time\\n # has passed\\n self._last_activity_time = time.time()\\n while not self._is_ringing:\\n time.sleep(0.01)\\n if self._server_mode and time.time() > self._last_activity_time + INACTIVITY_EXIT_TIME:\\n self.logger.info(f\\\"Timed out - no activity for {INACTIVITY_EXIT_TIME}s. Exiting.\\\")\\n return\\n\\n self.logger.info(f\\\"Starting to ring {self.row_generator.summary_string()}\\\")\\n if self._server_mode:\\n self._tower.set_is_ringing(True)\\n\\n while self._is_ringing:\\n self.tick()\\n time.sleep(0.01)\\n\\n self.logger.info(\\\"Stopping ringing!\\\")\\n if self._server_mode:\\n self._tower.set_is_ringing(False)\",\n \"def run_forever(func):\\n def forever_wrapped():\\n waittime = 1.\\n lastwait = time.time()\\n while True:\\n try:\\n func()\\n except KeyboardInterrupt: # we allow user to interrupt us ;-\\n print(\\\"User abort\\\")\\n return\\n except IOError as ioe:\\n print(\\\"Connection was closed: %s\\\" % str(ioe))\\n except IncompleteRead as ire:\\n print(\\\"Twitter sending us shit: %s\\\" % str(ire))\\n except RuntimeError as re:\\n print(\\\"Problem during this run: %s\\\" % str(re))\\n except BaseException as e:\\n traceback.print_exception(type(e), e, sys.exc_info()[2])\\n else:\\n print(\\\"Terminated... \\\", end=\\\"\\\")\\n\\n now = time.time()\\n # reset waittime when we ran for at least 10 minute without issues\\n if lastwait + waittime + 600 < now:\\n waittime = 1.\\n lastwait = now\\n\\n print(\\\"Restarting in %.0f seconds\\\" % waittime)\\n signal.alarm(0) # reset watchdog here :-/\\n time.sleep(waittime)\\n\\n # max wait time is 20min\\n waittime = min(20 * 60, waittime * 2) # exponential backoff\\n return forever_wrapped\",\n \"def run(self):\\n print \\\"running presence detection\\\"\\n r = rospy.Rate(10)\\n time.sleep(2)\\n\\n while not rospy.is_shutdown():\\n if self.running:\\n self.find_new_people()\\n self.follow_people()\\n\\n r.sleep()\",\n \"def dynamic_discovery(self):\\n while True:\\n sleep(DYNAMIC_DISCOVERY_SLEEP)\\n logging.debug(\\\"Starting Dynamic Discovery!\\\")\\n self.datastream_discovery()\",\n \"def run(self):\\n try:\\n self.eventloop.run_forever()\\n except KeyboardInterrupt:\\n self.logger.info(\\\"Interrupt received, shutting down.\\\")\\n except Exception:\\n self.logger.exception(\\\"Unhandled exception raised, shutting down.\\\")\\n finally:\\n self._shutdown()\\n self.logger.debug(\\\"Closing event loop\\\")\\n self.eventloop.close()\\n if self._restarting:\\n self.logger.info(f\\\"Restarting with command line: {sys.argv}\\\")\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def _run(self):\\n #print(\\\"try to connect run\\\")\\n while True:\\n self._connect()\\n while not self.connected and self.auto_retry is not None:\\n gevent.sleep(self.auto_retry)\\n self._connect()\\n if self.connected:\\n self.run()\\n if self.auto_retry is None:\\n break\",\n \"def run():\\n main()\",\n \"def run(self, forever=False, interval=300):\\n\\n bot_start_time = time.time()\\n\\n while True:\\n try:\\n self.process_posts()\\n except Exception as e:\\n logging.exception(\\\"bot:run\\\")\\n rollbar.report_exc_info()\\n\\n if not forever:\\n break\\n\\n sleep_interval = float(interval) - ((time.time() - bot_start_time) % float(interval))\\n\\n logging.info(\\\"Sleeping for {0} seconds until next run.\\\".format(sleep_interval))\\n time.sleep(sleep_interval)\",\n \"def run_cron(self):\\n logging.info(\\n 'Starting with the \\\"cron\\\" parameter, we will run once and then exit.'\\n )\\n self.request_messages()\\n logging.info(\\\"Nothing more to be done, we will exit.\\\")\\n exit(0)\",\n \"def run():\\n REDIRECT = False\\n LOG_FILE = \\\"truss.log\\\"\\n app = App(REDIRECT)\\n app.MainLoop()\",\n \"def main():\\n populate_satellites_array()\\n latitude = float(os.environ['LATITUDE'])\\n longitude = float(os.environ['LONGITUDE'])\\n radius = int(os.environ['RADIUS'])\\n timeout = 1\\n previous_satellites = []\\n while True:\\n if (last_updated[0] + 86400) < int(time.time()):\\n print('Expired data, updating from spacetrack')\\n cron_refresh_spacetrack_cache()\\n populate_satellites_array()\\n print('Checking {}, {}'.format(latitude, longitude))\\n currently_overhead = get_overhead_satellites_dicts(latitude, longitude, radius)\\n for sat in currently_overhead:\\n if not sat['name'] in previous_satellites:\\n announce_satellite(sat)\\n previous_satellites = [x['name'] for x in currently_overhead]\\n time.sleep(timeout)\",\n \"def entry(self):\\n if not os.path.isfile('model'):\\n train()\\n schedule.every(0.01).seconds.do(predict, self)\\n while True:\\n schedule.run_pending()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72144735","0.6544273","0.65426034","0.6278244","0.62634057","0.62595147","0.62210196","0.6201465","0.6139407","0.6137481","0.61167115","0.61131215","0.6071008","0.6063917","0.6063917","0.60003394","0.59724736","0.59668356","0.5963748","0.5945622","0.5936836","0.59040076","0.5903484","0.5892845","0.5874905","0.5873288","0.58592546","0.58299625","0.5803547","0.57959247","0.57953405","0.577273","0.57523626","0.57357067","0.57211226","0.5719907","0.5715126","0.5707896","0.56830585","0.56821495","0.5679543","0.56710726","0.56710726","0.56498355","0.56427485","0.56404","0.56289595","0.5628014","0.5607787","0.5598434","0.5579776","0.55669665","0.5563035","0.55585927","0.55467856","0.5528185","0.54999566","0.54930174","0.54751754","0.5463999","0.54469055","0.54431266","0.5440639","0.54283386","0.5425102","0.54056287","0.5400537","0.5400537","0.53740054","0.53667223","0.5366627","0.535698","0.5300993","0.52972645","0.5295563","0.52951694","0.5290738","0.5290547","0.5286135","0.5275063","0.52656186","0.52635753","0.52603555","0.52590907","0.52443784","0.5240612","0.5240149","0.5237152","0.5236504","0.5225833","0.5223538","0.52135843","0.5201749","0.5200833","0.5195628","0.51929486","0.5176574","0.51711863","0.5170803","0.51686037"],"string":"[\n \"0.72144735\",\n \"0.6544273\",\n \"0.65426034\",\n \"0.6278244\",\n \"0.62634057\",\n \"0.62595147\",\n \"0.62210196\",\n \"0.6201465\",\n \"0.6139407\",\n \"0.6137481\",\n \"0.61167115\",\n \"0.61131215\",\n \"0.6071008\",\n \"0.6063917\",\n \"0.6063917\",\n \"0.60003394\",\n \"0.59724736\",\n \"0.59668356\",\n \"0.5963748\",\n \"0.5945622\",\n \"0.5936836\",\n \"0.59040076\",\n \"0.5903484\",\n \"0.5892845\",\n \"0.5874905\",\n \"0.5873288\",\n \"0.58592546\",\n \"0.58299625\",\n \"0.5803547\",\n \"0.57959247\",\n \"0.57953405\",\n \"0.577273\",\n \"0.57523626\",\n \"0.57357067\",\n \"0.57211226\",\n \"0.5719907\",\n \"0.5715126\",\n \"0.5707896\",\n \"0.56830585\",\n \"0.56821495\",\n \"0.5679543\",\n \"0.56710726\",\n \"0.56710726\",\n \"0.56498355\",\n \"0.56427485\",\n \"0.56404\",\n \"0.56289595\",\n \"0.5628014\",\n \"0.5607787\",\n \"0.5598434\",\n \"0.5579776\",\n \"0.55669665\",\n \"0.5563035\",\n \"0.55585927\",\n \"0.55467856\",\n \"0.5528185\",\n \"0.54999566\",\n \"0.54930174\",\n \"0.54751754\",\n \"0.5463999\",\n \"0.54469055\",\n \"0.54431266\",\n \"0.5440639\",\n \"0.54283386\",\n \"0.5425102\",\n \"0.54056287\",\n \"0.5400537\",\n \"0.5400537\",\n \"0.53740054\",\n \"0.53667223\",\n \"0.5366627\",\n \"0.535698\",\n \"0.5300993\",\n \"0.52972645\",\n \"0.5295563\",\n \"0.52951694\",\n \"0.5290738\",\n \"0.5290547\",\n \"0.5286135\",\n \"0.5275063\",\n \"0.52656186\",\n \"0.52635753\",\n \"0.52603555\",\n \"0.52590907\",\n \"0.52443784\",\n \"0.5240612\",\n \"0.5240149\",\n \"0.5237152\",\n \"0.5236504\",\n \"0.5225833\",\n \"0.5223538\",\n \"0.52135843\",\n \"0.5201749\",\n \"0.5200833\",\n \"0.5195628\",\n \"0.51929486\",\n \"0.5176574\",\n \"0.51711863\",\n \"0.5170803\",\n \"0.51686037\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73165596"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90997,"cells":{"query":{"kind":"string","value":"Run each source once, passing artifacts to each operator."},"document":{"kind":"string","value":"def run_once(self):\n # Track some statistics about artifacts in a summary object.\n summary = collections.Counter()\n\n for source in self.sources:\n # Run the source to collect artifacts.\n self.logger.info(f\"Running source '{source}'\")\n try:\n # get the generator of onions\n onions = self.sources[source].run()\n except Exception as e:\n self.logger.error(e)\n self.logger.error(traceback.print_exc())\n continue\n\n # Process onions with each operator.\n for operator in self.operators:\n self.logger.info(f\"Processing found onions with operator '{operator}'\")\n try:\n self.operators[operator].process(onions)\n # Save the source onion with collected data\n except Exception as e:\n self.logger.error(e)\n self.logger.error(traceback.print_exc())\n continue\n\n\n\n# # Record stats and update the summary.\n# types = artifact_types(doc.get('interestingKeywords'))\n# summary.update(types)\n# for artifact_type in types:\n# self.logger.info(f'types[artifact_type]')\n\n # Log the summary.\n self.logger.info(f\"New artifacts: {dict(summary)}\")"},"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 run(self):\n\t\tfor source in self.sources:\n\t\t\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\n\t\t\tfor r in source.get_elements():\n\t\t\t\tr.set_source(source)\n\t\t\t\tself._queue.put(r)\n\n\t\t\t\t# Extra tracking stuff below:\n\t\t\t\twith self._c_lock:\n\t\t\t\t\tself._total_count+= 1\n\t\t\t\tif self._testing_cache is not None:\n\t\t\t\t\tself._testing_cache.append(r)\n\t\t#print(\"Element loading complete.\\n\")\n\t\tself._running = False","def run(self):\n\t\tself._keep_running = True\n\t\tif self._testing_cache is not None:\n\t\t\tself._testing_cache = []\n\n\t\tfor source in self.sources:\n\t\t\ttry:\n\t\t\t\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\n\t\t\t\tfor r in source.get_elements():\n\t\t\t\t\tif not self._keep_running:\n\t\t\t\t\t\treturn\n\t\t\t\t\tr.set_source(source)\n\t\t\t\t\twhile self._keep_running:\n\t\t\t\t\t\ttry: # Keep trying to add this element to the queue, with a timeout to catch any stop triggers.\n\t\t\t\t\t\t\tself._queue.put(r, timeout=1)\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\texcept queue.Full:\n\t\t\t\t\t\t\tpass\n\t\t\t\t\t# Extra tracking stuff below:\n\t\t\t\t\twith self._c_lock:\n\t\t\t\t\t\tself._total_count += 1\n\t\t\t\t\tif self._testing_cache is not None:\n\t\t\t\t\t\tself._testing_cache.append(r)\n\t\t\texcept ConnectionError as ce:\n\t\t\t\tprint(str(ce).upper())\n\t\tself._keep_running = False","def runall(sources='sources'):\n init()\n upload_sources(sources)\n compile()\n run()","def __call__(self, images, targets):\n pass","def run_all(operations=ops):\n for operation in operations:\n run(operation)","def execute(self, targets):","def run(self):\n count = self.neuron_count\n for i in range(0, count):\n self.run(i)","def update(self):\n with enforce_unique_instance('repository', blocking=True):\n for dist, component in self.pending:\n self.update_sources(dist, component)","def run(self):\n for tool in self.tools:\n tool.run()\n return","def run(layers):","def main() -> co.Parallel:\n actors = [\"Oprah Winfrey\", \"Kate Mara\", \"Don Cheadle\", \"Dwayne Johnson\"]\n root = co.Parallel(image=_get_image())\n for actor in actors:\n root[actor] = co.Lazy(\n f\"python pipeline.py all_by_actor '{actor}'\"\n )\n return root","def sync(self):\n if (len(self._source_list) == 0) or (len(self._dest_list) == 0):\n return\n \n for src in self._source_list:\n self._sync('.', src, self._depth)","def run(self):\n self.assign_inputs()\n self.execute()\n self.collect_outputs()","def update_all_sources(source_data_filename, host_filename):\n\n # The transforms we support\n transform_methods = {\"jsonarray\": jsonarray}\n\n all_sources = sort_sources(recursive_glob(\"*\", source_data_filename))\n\n for source in all_sources:\n update_file = open(source, \"r\", encoding=\"UTF-8\")\n update_data = json.load(update_file)\n update_file.close()\n\n # we can pause updating any given hosts source.\n # if the update.json \"pause\" key is missing, don't pause.\n if update_data.get('pause', False):\n continue\n\n update_url = update_data[\"url\"]\n update_transforms = []\n if update_data.get(\"transforms\"):\n update_transforms = update_data[\"transforms\"]\n\n print(\"Updating source \" + os.path.dirname(source) + \" from \" + update_url)\n\n try:\n updated_file = get_file_by_url(update_url)\n\n # spin the transforms as required\n for transform in update_transforms:\n updated_file = transform_methods[transform](updated_file)\n\n # get rid of carriage-return symbols\n updated_file = updated_file.replace(\"\\r\", \"\")\n\n hosts_file = open(\n path_join_robust(BASEDIR_PATH, os.path.dirname(source), host_filename),\n \"wb\",\n )\n write_data(hosts_file, updated_file)\n hosts_file.close()\n except Exception:\n print(\"Error in updating source: \", update_url)","def _load_sources(self):\n self.point_sources= []\n if os.path.exists(os.path.join(self.folder,'pickle.zip')):\n pzip = zipfile.ZipFile(os.path.join(self.folder,'pickle.zip'))\n files = ['pickle/HP12_%04d.pickle' %i for i in range(1728)]\n assert all(f in pzip.namelist() for f in files), 'Improper model zip file'\n opener = pzip.open\n else:\n files = glob.glob(os.path.join(self.folder, 'pickle', '*.pickle'))\n files.sort()\n opener = open\n self.nside = int(np.sqrt(len(files)/12))\n if len(files) != 12*self.nside**2:\n msg = 'Number of pickled ROI files, %d, found in folder %s, not consistent with HEALpix' \\\n % (len(files),os.path.join(self.folder, 'pickle'))\n raise Exception(msg)\n \n ####self.global_sources = sources.GlobalSourceList() # allocate list to index parameters for global sources\n self.extended_sources=[] # list of unique extended sources\n self.changed=set() # to keep track of extended models that are different from catalog\n moved=0\n nfreed = 0\n self.tagged=set()\n source_names =[]\n for i,file in enumerate(files):\n p = pickle.load(opener(file))\n index = int(os.path.splitext(file)[0][-4:])\n assert i==index, 'logic error: file name %s inconsistent with expected index %d' % (file, i)\n roi_sources = p.get('sources', {}) # don't know why this needed\n extended_names = {} if (self.__dict__.get('extended_catalog') is None) else self.extended_catalog.names\n for key,item in roi_sources.items():\n if key in extended_names: continue\n if key in source_names:\n #if not self.quiet: print ('SkyModel warning: source with name %s in ROI %d duplicates previous entry: ignored'%(key, i))\n continue\n source_names.append(key)\n skydir = item['skydir']\n if self.update_positions is not None:\n ellipse = item.get('ellipse', None)\n ts = item['ts']\n if ellipse is not None and not np.any(np.isnan(ellipse)) :\n fit_ra, fit_dec, a, b, ang, qual, delta_ts = ellipse\n if qual<5 and a < 0.2 and \\\n ts>self.update_positions and delta_ts>0.1:\n skydir = SkyDir(float(fit_ra),float(fit_dec))\n moved +=1\n self.tagged.add(i)\n \n ps = sources.PointSource(name=key,\n skydir=skydir, model= sources.convert_model(item['model']),\n ts=item['ts'],band_ts=item['band_ts'], index=index)\n if sources.validate(ps,self.nside, self.filter):\n self._check_position(ps) # check that it is not coincident with previous source(warning for now?)\n self.point_sources.append( ps)\n # make a list of extended sources used in the model \n names = p.get('diffuse_names')\n for name, oldmodel in zip(names, p['diffuse']):\n model = sources.convert_model(oldmodel) # convert from old Model version if necessary \n key = name.split('_')[0]\n if key in self.diffuse_dict:\n self.diffuse_dict.add_model(index, name, model)\n elif self.extended_catalog_name=='ignore': \n continue\n else:\n try:\n es = self.extended_catalog.lookup(name) if self.extended_catalog is not None else None\n except Exception as msg:\n print ('Skymodel: Failed to create model for %s' %name)\n raise\n if es is None:\n #raise Exception( 'Extended source %s not found in extended catalog' %name)\n print ('SkyModel warning: Extended source %s not found in extended catalog, removing' %name)\n continue\n if self.hpindex(es.skydir)!=index: continue\n \n if es.model.name!=model.name:\n if name not in self.changed:\n if not self.quiet: print ('SkyModel warning: catalog model %s changed from %s for source %s: keeping change'%\\\n (es.model.name, model.name, name))\n self.changed.add(name)\n es.smodel=es.model=model #update with current fit values always\n if sources.validate(es,self.nside, self.filter): #lambda x: True): \n self.extended_sources.append(es)\n # check for new extended sources not yet in model\n self._check_for_extended()\n if self.update_positions and moved>0:\n print ('updated positions of %d sources, healpix ids in tagged' % moved)","def calculator_build_events_from_sources(self):\n gsims_by_trt = self.calculator.csm.full_lt.get_gsims_by_trt()\n print('FetchOpenQuake: self.calculator.csm.src_groups = ')\n print(self.calculator.csm.src_groups)\n sources = self.calculator.csm.get_sources()\n print('FetchOpenQuake: sources = ')\n print(sources)\n for src in sources:\n src.nsites = 1 # avoid 0 weight\n src.num_ruptures = src.count_ruptures()\n maxweight = sum(sg.weight for sg in self.calculator.csm.src_groups) / (\n self.calculator.oqparam.concurrent_tasks or 1)\n print('FetchOpenQuake: weights = ')\n print([sg.weight for sg in self.calculator.csm.src_groups])\n print('FetchOpenQuake: maxweight = ')\n print(maxweight)\n eff_ruptures = general.AccumDict(accum=0) # trt => potential ruptures\n calc_times = general.AccumDict(accum=np.zeros(3, np.float32)) # nr, ns, dt\n allargs = []\n if self.calculator.oqparam.is_ucerf():\n # manage the filtering in a special way\n for sg in self.calculator.csm.src_groups:\n for src in sg:\n src.src_filter = self.calculator.srcfilter\n srcfilter = calc.filters.nofilter # otherwise it would be ultra-slow\n else:\n srcfilter = self.calculator.srcfilter\n logging.info('Building ruptures')\n for sg in self.calculator.csm.src_groups:\n if not sg.sources:\n continue\n logging.info('Sending %s', sg)\n par = self.calculator.param.copy()\n par['gsims'] = gsims_by_trt[sg.trt]\n for src_group in sg.split(maxweight):\n allargs.append((src_group, srcfilter, par))\n\n smap = [] \n for curargs in allargs:\n smap.append(calc.stochastic.sample_ruptures(curargs[0], curargs[1], curargs[2]))\n\n print('smap = ')\n print(smap)\n self.calculator.nruptures = 0\n mon = self.calculator.monitor('saving ruptures')\n for tmp in smap:\n dic = next(tmp)\n print(dic)\n # NB: dic should be a dictionary, but when the calculation dies\n # for an OOM it can become None, thus giving a very confusing error\n if dic is None:\n raise MemoryError('You ran out of memory!')\n rup_array = dic['rup_array']\n if len(rup_array) == 0:\n continue\n if dic['calc_times']:\n calc_times += dic['calc_times']\n if dic['eff_ruptures']:\n eff_ruptures += dic['eff_ruptures']\n with mon:\n n = len(rup_array)\n rup_array['id'] = np.arange(\n self.calculator.nruptures, self.calculator.nruptures + n)\n self.calculator.nruptures += n\n hdf5.extend(self.calculator.datastore['ruptures'], rup_array)\n hdf5.extend(self.calculator.datastore['rupgeoms'], rup_array.geom)\n\n if len(self.calculator.datastore['ruptures']) == 0:\n raise RuntimeError('No ruptures were generated, perhaps the '\n 'investigation time is too short')\n\n # must be called before storing the events\n self.calculator.store_rlz_info(eff_ruptures) # store full_lt\n self.calculator.store_source_info(calc_times)\n imp = commonlib.calc.RuptureImporter(self.calculator.datastore)\n print('self.calculator.datastore.getitem(ruptures)')\n print(self.calculator.datastore.getitem('ruptures'))\n with self.calculator.monitor('saving ruptures and events'):\n imp.import_rups_events(self.calculator.datastore.getitem('ruptures')[()], getters.get_rupture_getters)","def all(source=None):\n package(source)\n deploy()","def run(self):\r\n for pipe in self.inputs:\r\n for row in pipe.rows():\r\n self.put(row)","def warmup_one_iter(self) -> None:\n self.model.eval()\n for batch_data in self.testloader:\n images, labels = (\n batch_data[0].to(self.device),\n batch_data[1].to(self.device),\n )\n\n # forward + backward + optimize\n loss, outputs = self.criterion(\n model=self.model, images=images, labels=labels\n )\n return None","def query_initial_sources(self):\n self.search_thread_pool.waitForDone(0)\n # self.init_vector_layers()\n username, password, api_key, max_items_to_return = SettingsOps.get_settings()\n errors = []\n SettingsOps.validate_stored_info(username, password, api_key, max_items_to_return, errors)\n if len(errors) == 0:\n source_runnable = SourceRunnable(username, password, api_key, DEFAULT_ORDER_PARAMS)\n source_runnable.source_object.task_complete.connect(self.on_new_source)\n self.init_progress_bar()\n self.search_thread_pool.start(source_runnable)","def __call__(self, images, targets):\n return images, targets","def main(unused_argv):\n make_dir(FLAGS.raw_dir)\n\n # Get paths of download/extracted training and evaluation files.\n print(\"Downloading data from source\")\n train_files = get_raw_files(FLAGS.raw_dir, constants.TRAIN_DATA_SOURCES)\n eval_files = get_raw_files(FLAGS.raw_dir, constants.EVAL_DATA_SOURCES)","def process(self, args):\n for benchmark_file in args.benchmark_files:\n self.process_individual_file(benchmark_file)\n self.total_files += 1","def resolve_components(self) -> None:\n for mix in self:\n if not isinstance(mix, Mix):\n continue\n mix.with_experiment(self, True)","def run_all_layers(self, img): # noqa\n s1_outputs = [s1(img) for s1 in self.s1_units]\n\n # Each C1 layer pools across two S1 layers\n c1_outputs = []\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\n c1_outputs.append(c1(s1_outputs[i:i+2]))\n\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\n\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs","def runall():\n sclogic.runall()","def AutoQuakePycker_run():\n import glob\n from itertools import product\n import multiprocessing\n import logging\n import more_itertools as mit\n from munch import munchify\n import os\n import yaml\n from obspy import read_events, Catalog\n\n logger = multiprocessing.log_to_stderr(logging.DEBUG)\n # Read in config file\n with open(\"config.yaml\", \"r\") as ymlfile:\n cfg = munchify(yaml.safe_load(ymlfile))\n initial_cat = read_events(cfg.input.lassie_cat_file)\n\n # Read in station locations from file\n sta_list = [[l.split()[1], float(l.split()[3]), float(l.split()[4])] for l\n in open(\"NLLOC_run/run.in\", \"r\") if l.split()[0] == \"GTSRCE\"]\n sta_locs = {sta[0]: {\"lat\": sta[1], \"lon\": sta[2]} for sta in sta_list}\n if cfg.output.FORCE_RECALC is True:\n filelist = glob.glob(os.path.join(\"refined_events\", \"*.xml\"))\n for f in filelist:\n os.remove(f)\n if cfg.run.nproc == \"auto\":\n nproc = multiprocessing.cpu_count()\n else:\n nproc = cfg.run.nproc\n # Get events for which data currently is available\n cat_filter = Catalog()\n for n, event in enumerate(initial_cat):\n e_id = event.event_descriptions[0].text\n if e_id in os.listdir(\"{:}/\".format(cfg.input.DIR_TO_EVENTDIRS)):\n if (cfg.output.FORCE_RECALC is False and\n os.path.exists(\"refined_events/{:}.xml\".format(e_id))):\n print(\"Already have this evening ... skipping\")\n else:\n cat_filter.append(event)\n # Split catalogue across multiple processes and process in parallel\n cat_split = [i for i in mit.divide(nproc, cat_filter)]\n # process_events(cat_split[7], 7)\n pool = multiprocessing.Pool(processes=nproc)\n print(\"hello\")\n a = pool.starmap(process_events, product(cat_split, range(nproc), cfg,\n sta_locs))\n\n logger.debug(a)","def bulk_train(self):\n logger.info(\"collecting subfolders - relations\")\n relations = self.collect_subfolders(self.input_dir)\n logger.info(\"relations - {}\".format(relations))\n\n execution_times = []\n\n for rel, rel_path in tqdm(relations.items(), desc=\"relations\"):\n logger.info(\"collecting training files from {}\".format(rel_path))\n tr_files = self.collect_files(rel_path, self.regexp_train)\n hyper_params = self.get_hyperparams()\n hyper_params['graph'] = tr_files\n\n output_folder = os.path.join(self.output_dir, rel)\n if not os.path.exists(output_folder):\n logger.info(\"creating {} (did not exist)\".format(output_folder))\n os.makedirs(output_folder)\n\n for params in tqdm(ParameterGrid(hyper_params), desc=\"training embedding\"):\n logger.info(\"hyperparams: {}\".format(params))\n train_file = params['graph']\n model_name = self.compute_model_name(params, output_folder)\n logger.info('training starspace model \"{}\" from file \"{}\"'.format(\n model_name, train_file))\n external_output, delta = self.call_starspace(params, train_file, model_name)\n logger.info(\"executed in {:0.2f}s\".format(delta))\n\n logger.info(\"external command output logged in {}\".format(self.external_log))\n if not os.path.exists(self.output_dir):\n logger.info(\"creating {} (did not exist)\".format(self.output_dir))\n os.makedirs(self.output_dir)\n\n with open(self.external_log, 'a') as f:\n f.write(external_output)\n\n execution_times.append(dict({ 'time': delta }, **params))\n \n return execution_times","def __init__(self, sources, folder):\r\n # TODO: include possibility of multiple aggregating functions?\r\n self._acc = folder\r\n if type(sources) is not list:\r\n sources = [sources]\r\n\r\n self._sources = sources\r\n for k in range(len(sources)):\r\n if type(sources[k]) == type(self):\r\n sources[k] = OnEveryDt(1, sources[k])\r\n self._events = [event.subscribe(source, _(self)._update, self) for source in self._sources]","def process_images(self):\n source_images = self.get_build_images()\n self.log.info(\"Got %s images for publishing. Processing..\", len(source_images))\n\n for image in source_images:\n self.fetch_image(image)\n\n for target in image.push_registries:\n for tag in image.release_tags:\n repository = \"%s/%s\" % (target, image.repository.name)\n self.tag_image(image, repository, tag)\n retry_count = 1\n while retry_count <= self.retry_limit:\n self.log.info(\"Pushing %s:%s to %s (%d/%d)\", repository, tag, target, retry_count, self.retry_limit)\n try:\n self.publish_image(target, repository, tag)\n break\n except ImagePushError as e:\n self.log.error(\"%s\", e.message)\n retry_count = retry_count + 1\n else:\n return False\n return True","def main():\n datasets = {}\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\"Processing datasets and fitting base models\"):\n logger.info(f\"processing dataset {dataset_name}\")\n clusters_path: Optional[str] = None\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \"_clusters.json\")\n train_pairs_path = None\n val_pairs_path = None\n test_pairs_path = None\n else:\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \"train_pairs.csv\")\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \"val_pairs.csv\")\n if not os.path.exists(val_pairs_path):\n val_pairs_path = None\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \"test_pairs.csv\")\n\n logger.info(f\"loading dataset {dataset_name}\")\n anddata = ANDData(\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_signatures.json\"),\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_papers.json\"),\n name=dataset_name,\n mode=\"train\",\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_specter.pickle\"),\n clusters=clusters_path,\n block_type=BLOCK_TYPE,\n train_pairs=train_pairs_path,\n val_pairs=val_pairs_path,\n test_pairs=test_pairs_path,\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\n val_pairs_size=N_VAL_TEST_SIZE,\n test_pairs_size=N_VAL_TEST_SIZE,\n preprocess=True,\n )\n\n logger.info(f\"featurizing {dataset_name}\")\n train, val, test = featurize(\n anddata,\n FEATURIZER_INFO,\n n_jobs=N_JOBS,\n use_cache=True,\n chunk_size=100,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\n nan_value=NAN_VALUE,\n )\n X_train, y_train, nameless_X_train = train\n X_val, y_val, nameless_X_val = val\n X_test, y_test, nameless_X_test = test\n\n dataset = {}\n dataset[\"anddata\"] = anddata\n dataset[\"X_train\"] = X_train\n dataset[\"y_train\"] = y_train\n dataset[\"X_val\"] = X_val\n dataset[\"y_val\"] = y_val\n dataset[\"X_test\"] = X_test\n dataset[\"y_test\"] = y_test\n dataset[\"nameless_X_train\"] = nameless_X_train\n dataset[\"nameless_X_val\"] = nameless_X_val\n dataset[\"nameless_X_test\"] = nameless_X_test\n dataset[\"name\"] = anddata.name\n datasets[dataset_name] = dataset\n\n anddatas = [\n datasets[dataset_name][\"anddata\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in PAIRWISE_ONLY_DATASETS\n ]\n\n X_train = np.vstack([datasets[dataset_name][\"X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n y_train = np.hstack([datasets[dataset_name][\"y_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n X_val = np.vstack(\n [datasets[dataset_name][\"X_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n y_val = np.hstack(\n [datasets[dataset_name][\"y_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n\n nameless_X_train = np.vstack([datasets[dataset_name][\"nameless_X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n nameless_X_val = np.vstack(\n [\n datasets[dataset_name][\"nameless_X_val\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in {\"augmented\"}\n ]\n )\n\n logger.info(\"fitting pairwise\")\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\n union_classifier.fit(X_train, y_train, X_val, y_val)\n\n nameless_union_classifier = None\n if USE_NAMELESS_MODEL:\n logger.info(\"nameless fitting pairwise for \" + str(SOURCE_DATASET_NAMES))\n nameless_union_classifier = PairwiseModeler(\n n_iter=N_ITER,\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\n )\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\n logger.info(\"nameless pairwise fit for \" + str(SOURCE_DATASET_NAMES))\n\n logger.info(\"fitting clusterer for\")\n union_clusterer = Clusterer(\n FEATURIZER_INFO,\n union_classifier.classifier,\n cluster_model=FastCluster(),\n search_space=search_space,\n n_jobs=N_JOBS,\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\n )\n union_clusterer.fit(anddatas)\n print(\n \"best clustering parameters:\",\n union_clusterer.best_params,\n )\n\n models = {}\n models[\"clusterer\"] = union_clusterer\n\n with open(\n f\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\",\n \"wb\",\n ) as _pickle_file:\n pickle.dump(models, _pickle_file)\n logger.info(\"Done.\")","def test_3():\n \n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n multiplicand=2, addend=1)\n\n def g(in_streams, out_streams):\n t = Stream('t')\n filter_then_square(in_streams[0], t,\n filter_threshold=20)\n print_stream(t, name='p1')\n\n def sums(in_streams, out_streams):\n s = Stream('s')\n sum_window(in_streams[0], s, window_size=3, step_size=3)\n print_stream(s, name=' p2')\n\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n }\n },\n 'process_1':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': g,\n 'sources': {}\n },\n 'process_2':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': sums,\n 'sources': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'process_1':\n {\n },\n 'process_2':\n {\n }\n }\n\n multicore(processes, connections)","def multi_run_wrapper(args):\n\treturn img_preprocessing(*args)","def run():\n\n today = datetime.now().strftime(\"%Y-%m-%d\")\n log_file = os.path.abspath(\"logs/{}.log\".format(today))\n logger = RsmasLogger(\"pipeline\", log_file)\n\n images = get_list_of_images()\n # LOG: list of images to process\n logger.log(loglevel.INFO, [img.key for img in images])\n\n for im in images:\n\n logger.log(loglevel.INFO, \"Processing image: {}\".format(im.key))\n\n file_path = \"{}/{}\".format(im.bucket_name, im.key)\n full_path = \"{}_full.jpg\"\n mod_path = \"{}_mod.jpg\"\n aws_path = \"{}/{}/{}/{}\"\n try:\n haz_id, haz_name, sat_name, sat_dir, img_type, img_date, center = summary.pull_summary_data(\n \"/vsis3/{}\".format(file_path))\n sat_id = Satellite.from_params(sat_name, bool(sat_dir))\n except:\n # LOG: error in image metadata format\n logger.log(loglevel.ERROR, '\\tThere was an error in the metadata format of the image. Skipping.')\n continue\n\n aws_path = aws_path.format(haz_id, sat_id, img_type, img_date)\n full_path = full_path.format(img_date)\n mod_path = mod_path.format(img_date)\n\n # 1. Read in image file\n with rasterio.open(\"s3://{}\".format(file_path)) as data:\n band = data.read(1)\n img = plot.show(band)\n img.get_figure().savefig(full_path, dpi=300)\n\n # 3. Compress image\n compressed = immanip.compress_image(full_path, compression_amount=0.3)\n\n # 4 - 5. Pad image and add date on image\n text_image = immanip.add_text_to_image(compressed, img_date)\n\n # 6. Save image locally\n text_image.save(mod_path.format(img_date))\n mod_path_aws = save.get_s3_url(\"{}/{}\".format(aws_path, mod_path))\n full_path_aws = save.get_s3_url(\"{}/{}\".format(aws_path, full_path))\n\n tif_path_aws = save.get_s3_url(\"{}/{}\".format(aws_path, im.key))\n\n # LOG: images successfully moved to S3 bucket\n # LOG: mod_path_aws, full_path_aws, tif_path_aws\n\n hazard = Hazard(haz_id, haz_name, HazardType.VOLCANO, Location(center[0], center[1]), Date(img_date), 0)\n satellite = Satellite.from_params(sat_name, bool(sat_dir))\n image = Image(str(randint(1, 10000000)),\n haz_id,\n satellite,\n ImageType.from_string(img_type),\n Date(img_date),\n ImageURL(full_path_aws),\n ImageURL(tif_path_aws),\n ImageURL(mod_path_aws))\n\n try:\n db = Database()\n except ConnectionError:\n logger.log(loglevel.ERROR, \"\\tThere was an error while connecting to the database. Skipping this image.\")\n continue\n\n db.create_new_hazard(hazard)\n db.create_new_satellite(satellite)\n db.create_new_image(image)\n\n db.close()\n\n # LOG: database successfully updated\n logger.log(loglevel.INFO, \"\\tDatabase succesfully updated.\")\n\n save.save_image_s3(mod_path, \"{}/{}\".format(aws_path, mod_path))\n save.save_image_s3(full_path, \"{}/{}\".format(aws_path, full_path))\n save.move_tif(im.key, \"{}/{}\".format(aws_path, im.key))\n\n logger.log(loglevel.INFO, \"\\tImages were successfully uploaded to the S3 bucket\")\n logger.log(loglevel.INFO, \"\\t\\tmod_path_aws: {}\".format(mod_path_aws))\n logger.log(loglevel.INFO, \"\\t\\tfull_path_aws: {}\".format(full_path_aws))\n logger.log(loglevel.INFO, \"\\t\\ttif_path_aws: {}\".format(tif_path_aws))\n\n # LOG: image completed\n logger.log(loglevel.INFO, \"\\tProcessing of {} completed.\".format(im.key))\n\n # LOG: finished processing images\n logger.log(loglevel.INFO, \"Processing complete.\")","def reduce_run():","def _iterate_over_files(self):\n stats = Statistics()\n\n args = arguments.Args()\n\n for file in args.files:\n\n if isimage(file):\n before_size = stats.calculate_before_optimization(file)\n\n puts(\"%s %s\" % (\n e(\"==>\"),\n os.path.basename(file))\n )\n\n if \"--lossy\" in args.flags:\n Optimize.lossy(file)\n if \"--lossless\" in args.flags:\n Optimize.lossless(file)\n after_size = stats.calculate_after_optimization(file)\n\n puts(\"%s %s (%s)\" % (\n p(\"<==\"),\n os.path.basename(file),\n s(after_size) if after_size < before_size else after_size\n ))\n\n stats.show_statistics()","def __init__(self):\n self.train(positivity_files, 0)\n self.train(subjectivity_files, 1)","def compute(self, inputs, outputs):\n\n log.info(f\"Start optimisation iteration: {Rt.counter}\")\n\n # Update the geometry dictionary\n for name, infos in Rt.geom_dict.items():\n infos[1].append(inputs[name][0])\n\n if Rt.counter == 0:\n\n # For the first iteration, update the CPACS file from previous module\n cpacs_in = Rt.modules[0].cpacs_in\n cpacs_out = Rt.modules[0].cpacs_out\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\n\n else:\n\n for m, module in enumerate(Rt.modules):\n\n # Increment name of output CPACS file\n Rt.modules[m].cpacs_out = Path(\n Rt.modules[m].cpacs_out.parents[0],\n \"iter_\" + str(Rt.counter).rjust(2, \"0\") + \".xml\",\n )\n\n if m == 0:\n\n # Use output of the last module of the previous iteration as input\n Rt.modules[m].cpacs_in = Rt.modules[-1].cpacs_out\n\n # Update the geometry of the CPACS file\n cpacs_in = Rt.modules[m].cpacs_in\n cpacs_out = Rt.modules[m].cpacs_out\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\n\n # # The first module of the loop must update its output where the input\n # # was saved because it has been updated by \"update_cpacs_file\" function.\n # Rt.modules[m].cpacs_in = Rt.modules[m].cpacs_out\n\n else:\n\n # Increment name of input CPACS file\n Rt.modules[m].cpacs_in = Path(\n Rt.modules[m].cpacs_in.parents[0],\n \"iter_\" + str(Rt.counter).rjust(2, \"0\") + \".xml\",\n )\n\n Rt.counter += 1","async def dispatch_auto_starts(self, ctx):\n for operation in self.config.dataflow.operations.values():\n if operation.inputs or not await self.ictx.check_conditions(\n operation, self.config.dataflow, ctx\n ):\n continue\n parameter_set = MemoryParameterSet(\n MemoryParameterSetConfig(ctx=ctx, parameters=[])\n )\n task = await self.nctx.dispatch(self, operation, parameter_set)\n task.operation = operation\n task.parameter_set = parameter_set\n yield task","def execute(self, images_and_density_maps):\n # these imports are used in eval(), don't remove them\n import CCAugmentation.outputs as cca_out\n import CCAugmentation.transformations as cca_trans\n _ = cca_out, cca_trans\n\n op_str = self._get_op_str()\n const_str = self._get_const_str()\n\n for image_and_density_map in images_and_density_maps:\n rand_str = self._get_rand_str()\n args_str = \",\".join([const_str, rand_str]) if const_str and rand_str else const_str + rand_str\n op = eval(f\"{op_str}({args_str})\")\n for result in op.execute([image_and_density_map]):\n yield result","def prepare(self) -> None:\n for name, step, kwargs in self.steps:\n self.stream = step(self.stream, **kwargs)","def run_multiple_test_cycles(self):\n # Perform as many cycles as required\n while self.args.repetitions >= 0:\n self.run_one_test_cycle()\n self.args.repetitions -= 1","def load_files_to_compare(self):\n self.first_source_data = load_path(self.path1)\n self.second_source_data = load_path(self.path2)","def run(self, inputs):\n for layer in self._layers:\n inputs = layer.calc(inputs)\n return inputs","def gen_stage_loop(cls, _opts, tests, put_next_stage, _put_result_stage):\n for test in tests:\n put_next_stage(test)","def run(self, *args, **kwargs) -> None:\n loop = tqdm(self.configs, desc='Configurations')\n for cfg in loop:\n loop.set_postfix_str(cfg.experiment_cfg['name'])\n for i in range(cfg.num_models):\n filename = None\n run_id = None\n if cfg.filenames is not None:\n if isinstance(cfg.filenames, str):\n filename = cfg.filenames\n else:\n filename = cfg.filenames[i]\n elif cfg.run_ids is not None:\n run_id = cfg.run_ids[i]\n\n run_cfg = modelgen_cfg_to_runner_cfg(cfg, run_id=run_id, filename=filename)\n runner = Runner(run_cfg, persist_metadata=cfg.experiment_cfg)\n runner.run()\n\n # clear up memory between runs\n torch.cuda.empty_cache()","def Run(self):\n # get the runs object, which is an index for every tag.\n runs = self.GetRouteAndSave('runs')\n\n # collect sampled data.\n self.GetRouteAndSave('scalars')\n\n # now let's just download everything!\n for run, tag_type_to_tags in six.iteritems(runs):\n for tag_type, tags in six.iteritems(tag_type_to_tags):\n try:\n if tag_type == 'graph':\n # in this case, tags is a bool which specifies if graph is present.\n if tags:\n url = Url('graph', {'run': run})\n self.GetAndSave(url, GRAPH_SUFFIX, unzip=True)\n elif tag_type == 'images':\n for t in tags:\n images = self.GetRouteAndSave('images', {'run': run, 'tag': t})\n for im in images:\n url = 'individualImage?' + im['query']\n # pull down the images themselves.\n self.GetAndSave(url, IMAGE_SUFFIX)\n elif tag_type == 'audio':\n for t in tags:\n audio = self.GetRouteAndSave('audio', {'run': run, 'tag': t})\n for snd in audio:\n url = 'individualAudio?' + snd['query']\n # pull down the audio clips themselves\n self.GetAndSave(url, AUDIO_SUFFIX)\n elif tag_type == 'run_metadata':\n for t in tags:\n url = Url('run_metadata', {'run': run, 'tag': t})\n self.GetAndSave(url, GRAPH_SUFFIX, unzip=True)\n elif tag_type == 'firstEventTimestamp':\n pass\n else:\n for t in tags:\n # Save this, whatever it is :)\n self.GetRouteAndSave(tag_type, {'run': run, 'tag': t})\n except IOError as e:\n PrintAndLog('Retrieval failed for %s/%s/%s' % (tag_type, run, tags),\n tf.logging.WARN)\n PrintAndLog('Got Exception: %s' % e, tf.logging.WARN)\n PrintAndLog('continuing...', tf.logging.WARN)\n continue","def test_multi_source_explicit(self):\n with Graph('g') as graph:\n graph.source | Node('a') | graph.sink\n graph.source * 'out2' | Node('b') | 'in2' * graph.sink","def test_2():\n \n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n multiplicand=2, addend=1)\n\n def g(in_streams, out_streams):\n filter_then_square(in_streams[0], out_streams[0],\n filter_threshold=20)\n\n def h(in_streams, out_streams):\n s = Stream('s')\n sum_window(in_streams[0], s, window_size=3, step_size=3)\n print_stream(s, name=s.name)\n \n\n # Specify processes and connections.\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n },\n 'actuators': {}\n },\n 'filter_and_square_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('filtered', 'i')],\n 'compute_func': g,\n 'sources': {},\n 'actuators': {}\n },\n 'aggregate_and_output_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': h,\n 'sources': {},\n 'actuators': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('filter_and_square_process', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'filter_and_square_process' :\n {\n 'filtered' : [('aggregate_and_output_process', 'in')],\n },\n 'aggregate_and_output_process':\n {}\n }\n\n multicore(processes, connections)","def _threaded(self, *args, **kwargs):\n\n for target in self.targets:\n result = target(*args, **kwargs)\n self.queue.put(result)","def readSources(self):\n for sourceCount, sourceElement in enumerate(self.root.findall(\".sources/source\")):\n # shall we just read the UFO here?\n filename = sourceElement.attrib.get('filename')\n # filename is a path relaive to the documentpath. resolve first.\n sourcePath = os.path.abspath(os.path.join(os.path.dirname(self.path), filename))\n sourceName = sourceElement.attrib.get('name')\n if sourceName is None:\n # if the source element has no name attribute\n # (some authoring tools do not need them)\n # then we should make a temporary one. We still need it for reference.\n sourceName = \"temp_master.%d\"%(sourceCount)\n self.reportProgress(\"prep\", 'load', sourcePath)\n if not os.path.exists(sourcePath):\n raise MutatorError(\"Source not found at %s\"%sourcePath)\n sourceObject = self._instantiateFont(sourcePath)\n # read the locations\n sourceLocationObject = None\n sourceLocationObject = self.locationFromElement(sourceElement)\n\n if sourceLocationObject is None:\n raise MutatorError(\"No location defined for source %s\"%sourceName)\n\n # read lib flag\n for libElement in sourceElement.findall('.lib'):\n if libElement.attrib.get('copy') == '1':\n self.libSource = sourceName\n\n # read the groups flag\n for groupsElement in sourceElement.findall('.groups'):\n if groupsElement.attrib.get('copy') == '1':\n self.groupsSource = sourceName\n\n # read the info flag\n for infoElement in sourceElement.findall(\".info\"):\n if infoElement.attrib.get('copy') == '1':\n self.infoSource = sourceName\n if infoElement.attrib.get('mute') == '1':\n self.muted['info'].append(sourceName)\n\n # read the features flag\n for featuresElement in sourceElement.findall(\".features\"):\n if featuresElement.attrib.get('copy') == '1':\n if self.featuresSource is not None:\n self.featuresSource = None\n else:\n self.featuresSource = sourceName\n\n mutedGlyphs = []\n for glyphElement in sourceElement.findall(\".glyph\"):\n glyphName = glyphElement.attrib.get('name')\n if glyphName is None:\n continue\n if glyphElement.attrib.get('mute') == '1':\n if not sourceName in self.muted['glyphs']:\n self.muted['glyphs'][sourceName] = []\n self.muted['glyphs'][sourceName].append(glyphName)\n\n for kerningElement in sourceElement.findall(\".kerning\"):\n if kerningElement.attrib.get('mute') == '1':\n self.muted['kerning'].append(sourceName)\n\n # store\n self.sources[sourceName] = sourceObject, sourceLocationObject\n self.reportProgress(\"prep\", 'done')","def initialize_observation_files(tile_file_list):\n n_tiles = len(tile_file_list)\n if(n_tiles>0):\n for tile_file in tile_file_list:\n target_tile_pack = util.TargetTile(tile_file) \n target_tile_pack.write_results_to_file(tile_file)\n return","def _worker(pipelines: List[Pipeline], source: Queue, sink: Queue):\n pipelines = list(pipelines)\n for i, p in enumerate(pipelines):\n if isinstance(p, ConvertT2S):\n pipelines[i] = ConvertT2S()\n\n def processor(article):\n for p in pipelines:\n article = p(article)\n return article\n\n while True:\n article = source.get()\n if article == 'EXIT':\n return\n article = list(processor(article))\n sink.put(article)","def multiple_eval_for_loops_v1():","def run_batch_filter(self):\n if self.speed_data is None and self.flow_data is None and self.traveltime_data is None:\n print(\n 'Warning: The measurement data must be set before running the batch filter: use function self.set_meas_data()')\n\n # =======================================================================\n # the initial ensembles, which should have been set externally\n X_init = np.matrix(np.zeros((self.dim_state, self.num_ensembles)))\n print(\n 'Setting initial ensembles: rho {0}; qin {1}; qout {2}'.format(self.init_rho, self.init_qin, self.init_qout))\n for ens in range(0, self.num_ensembles):\n X_init[self.x_index['density'][0]:\n self.x_index['density'][self.num_cells - 1], ens] = self.init_rho\n X_init[self.x_index['qin'], ens] = self.init_qin\n X_init[self.x_index['qout'], ens] = self.init_qout\n\n # print('setted qin {0}; qout {1}'.format(X_init[self.x_index['qin'], ens], X_init[self.x_index['qout'], ens] ))\n # add noise to each ensemble\n X_init[:, ens] += np.matrix(np.random.multivariate_normal(\n np.zeros(self.dim_state), self.Q)).reshape((self.dim_state, 1))\n\n self.set_initial_ensembles(X_init)\n\n # =======================================================================\n # DEBUG\n # save the qin and qout in the corresponding probe data\n # save the initial state\n if self.__debug:\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\n self.qin_obs.append(np.nan)\n\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\n self.qout_obs.append(np.nan)\n\n # The enKF runs at the finest time grid\n # for each step, update the system\n for step in range(0, self.num_steps):\n\n # update status\n sys.stdout.write('\\r')\n sys.stdout.write('Status: filtering step {0}/{1}'.format(step, self.num_steps))\n sys.stdout.flush()\n # print('Status: filtering step {0}'.format(step))\n\n cur_time = (step + 1) * self.dur_steps\n\n # get the effective measurement\n eff_flow, eff_speed, eff_traveltime = self.__get_eff_meas(cur_time)\n\n # build the observation index\n self.y_index, self.dim_obs, y_obs, cov_noise = self.__build_obs_index(eff_flow, eff_speed, eff_traveltime)\n\n # update the estimate for this step\n est_state = self.update_estimate(y_obs, cov_noise, cur_time)\n\n # =======================================================================\n # DEBUG\n # save the qin and qout in the corresponding probe data\n # save the updated state\n if self.__debug:\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\n if 'flow' in self.y_index.keys() and self.__debug_entrance_sensor in self.y_index['flow'].keys():\n self.qin_obs.append(y_obs[self.y_index['flow'][self.__debug_entrance_sensor]])\n # print('y_index[flow]:{0}'.format(self.y_index['flow'].keys()))\n # print('y_obs[ y_index[flow][entrance] ]:{0}'.format(\n # y_obs[ self.y_index['flow'][self.__debug_entrance_sensor]],\n # self.__debug_entrance_sensor))\n else:\n self.qin_obs.append(np.nan)\n\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\n if 'flow' in self.y_index.keys() and self.__debug_exit_sensor in self.y_index['flow'].keys():\n self.qout_obs.append(y_obs[self.y_index['flow'][self.__debug_exit_sensor]])\n else:\n self.qout_obs.append(np.nan)\n # =======================================================================\n # save the estimated state\n self.est_state_all[:, step] = est_state\n\n # decouple and save into self.est_density, self.est_speed, self.est_queue, self.est_traveltime\n self.est_density[:, step] = est_state[0:self.num_cells, 0]\n\n # the speed is computed using the fundamental diagram\n for cell_id in range(0, self.num_cells):\n # use the static FD at this step\n self.est_speed[cell_id, step] = self.__rho2v(self.vm_cells[cell_id, 0], self.beta_cells[cell_id, 0],\n self.rhoc_cells[cell_id, 0], self.wc_cells[cell_id, 0],\n self.est_density[cell_id, step])\n\n # REMARK: the queue and travel time a post-processed from the speed field.\n # They are computed in cross_evaluation class for all algorithms\n # the queue length starts from the first cell with speed below queue_threshold to the end of road\n # index = (self.est_speed[:, step] <= self.queue_threshold)\n #\n # # filter out the outliers\n # index_smoothed = deepcopy(index)\n # outlier_max = 3\n # counter = 0\n # for i in range(0, len(index)):\n #\n # if index[i] == True:\n # # trigger the coutner\n # counter += 1\n # elif index[i] == False and counter != 0:\n # if counter <= outlier_max:\n # # found outliers\n # index_smoothed[ i-counter : i ] = False\n # # reset counter\n # counter = 0\n #\n # # if i != 0 and i != len(index)-1:\n # # if sum( index[i-1:i+3] ) >=2:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n # # elif i == 0:\n # # if sum(index[0: 5] ) >= 3:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n # # elif i == len(index)-1:\n # # if sum(index[ i-4 :len(index)]) >= 3:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n #\n # if sum(index_smoothed) <= 3: # use 4 to suppress false alarms\n # # if less or equal then 2 cells are in congestion, it may be caused by noise.\n # self.est_queue[step] = 0\n # else:\n # # if step > 105 and step < 115:\n # # print(sum(index_smoothed))\n # # print(index_smoothed)\n # # print(index)\n #\n # self.est_queue[step] = \\\n # self.len_cells*( self.num_cells - np.argmax(index_smoothed) )\n # # try:\n # # first_cong_cell_id = [x[0] for x in enumerate( self.est_speed[:,step] ) if x[1] < self.queue_threshold][0]\n # # except IndexError:\n # # # no congested cell\n # # first_cong_cell_id = self.num_cells\n # # # the estimated queue length\n # # self.est_queue[step] = self.len_cells*( self.num_cells - first_cong_cell_id )\n #\n # # the travel time estimate is computed by summing up the travel time in each cell\n # self.est_traveltime[step] = np.sum(self.len_cells/self.est_speed[:,step])\n\n\n # =======================================================================\n # DEBUG\n # plot the update\n if self.__debug:\n plot_len = 19\n # qin\n if False:\n if not np.isnan(self.qin_obs[-1]):\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\n ax1 = fig1.add_subplot(111)\n positions_f = np.arange(0, len(self.qin_f)) - 0.1\n positions_a = np.arange(0, len(self.qin_a)) + 0.1\n positions_obs = np.arange(0, len(self.qin_obs))\n # predicted as red\n bp = ax1.boxplot(self.qin_f[-plot_len:],\n positions=positions_f[-plot_len:], widths=0.15,\n patch_artist=False)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#FF4633', linewidth=1)\n # change fill color\n # box.set( facecolor = '#FF4633' )\n # corrected as green\n bp = ax1.boxplot(self.qin_a[-plot_len:],\n positions=positions_a[-plot_len:], widths=0.15, patch_artist=False)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#07891B', linewidth=1)\n # change fill color\n # box.set( facecolor = '#07891B' )\n # measurement as blue\n ax1.scatter(positions_obs[-plot_len:], self.qin_obs[-plot_len:], color='b', marker='o', s=40,\n label='Observation')\n ax1.set_title('qin')\n # x_ticks = np.arange(0, len(self.qin_f))\n # ax1.set_xticks(x_ticks[-plot_len:])\n plt.show()\n\n # qout\n if False:\n if not np.isnan(self.qout_obs[-1]):\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\n ax2 = fig2.add_subplot(111)\n positions_f = np.arange(0, len(self.qout_f)) - 0.1\n positions_a = np.arange(0, len(self.qout_a)) + 0.1\n positions_obs = np.arange(0, len(self.qout_obs))\n # predicted as red\n bp = ax2.boxplot(self.qout_f[-plot_len:], positions=positions_f[-plot_len:], widths=0.18,\n patch_artist=True)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#7570b3', linewidth=1)\n # change fill color\n box.set(facecolor='#FF4633')\n # corrected as green\n bp = ax2.boxplot(self.qout_a[-plot_len:], positions=positions_a[-plot_len:], widths=0.18,\n patch_artist=True)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#7570b3', linewidth=1)\n # change fill color\n box.set(facecolor='#07891B')\n # measurement as blue\n ax2.scatter(positions_obs[-plot_len:], self.qout_obs[-plot_len:], color='b', marker='o', s=30,\n label='Observation')\n ax2.set_title('qout')\n # x_ticks = np.arange(0, len(self.qout_f))\n # ax2.set_xticks(x_ticks[-plot_len:])\n\n plt.show()\n\n # plot the estimated qin and qout\n if self.__debug:\n if True:\n qin = np.squeeze(np.array(self.est_state_all[self.x_index['qin'], :]))\n qin_meas = np.array(self.qin_obs)[1:]\n print(len(qin), len(qin_meas))\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\n ax1 = fig1.add_subplot(111)\n t = np.arange(len(qin))\n ax1.plot(t, qin, 'r-', label='Estimated')\n not_nan = ~np.isnan(qin_meas)\n ax1.plot(t[not_nan], qin_meas[not_nan], 'b', label='Measured')\n ax1.legend()\n ax1.grid(True)\n ax1.set_title('qin')\n\n plt.draw()\n\n if True:\n qout = np.squeeze(np.array(self.est_state_all[self.x_index['qout'], :]))\n qout_meas = np.array(self.qout_obs)[1:]\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\n ax2 = fig2.add_subplot(111)\n t = np.arange(len(qout))\n ax2.plot(t, qout, 'r-', label='Estimated')\n not_nan = ~np.isnan(qout_meas)\n ax2.plot(t[not_nan], qout_meas[not_nan], 'b', label='Measured')\n ax2.set_title('qout')\n ax2.legend()\n ax2.grid(True)\n plt.draw()","def run_all(self):\n\n self.run_mash() ###Run MASH analysis\n self.filter_query() ###Filter fasta sequences out based on p value\n self.build_index(self.filtered_out_path) ###Build index for off-target analysis\n os.remove(self.filtered_out_path) ###Clean up intermediate fasta file\n self.format_gRNA(self.path1) ###Format everything in the right order\n self.run_OTF() ###Run off-target analysis\n self.output_parse() ###Parse output values and update table","def _collect_all(self):","def runScheduler(self):\n\n for source in self.sources:\n intervals = [\n int(self.sources[source]['metrics'][x]['interval']) for x\n in range(0, len(self.sources[source]['metrics']))]\n sourceInterval = self.gcd(intervals)\n self.sources[source]['sourceInterval'] = sourceInterval\n self.logger.debug(self.sources[source]['metrics'])\n\n self.scheduler.add_job(\n self.getDriverData, 'interval', args=[\n self.sources[source]['metrics']],\n seconds=sourceInterval)","def cache_test_sources(self):\n self.cache_extra_test_sources(self.smoke_test_src)","def run(self):\n self._validate_inputs()\n if self._destination_out_exists:\n print('Destination{} already skipping run'.format(self._inputs[-1]))\n try:\n if self.operator_func:\n self.operator_func(*self._inputs)\n else:\n raise RuntimeError('self.operator_func is not defined !!')\n except Exception as ex:\n print(ex)\n raise RuntimeError('self.operator_func failed !!')","def clsources(ctx):\n\t# TODO Use regex instead\n\t# this is a poor-man's hack, it relies on the assumption that files\n\t# start and end with parenthesis. Put a comment before, and you generate\n\t# wrong code. But the source is under my control anyways.\n\tfloat_srcfolder = ctx.path.find_node(inc + \"/ukoct/opencl/float/sources\")\n\tcommon_clsources = ctx.path.ant_glob(inc + \"/ukoct/opencl/common/**/*.cl\")\n\tfloat_clsources = [\n\t\tfloat_srcfolder.find_node(\"defs.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"coherent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"consistent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"intConsistent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"closed.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"stronglyClosed.inc.cl\"),\n\t]\n\tfloat_clsource = []\n\tfor node in common_clsources:\n\t\tsource = node.read()\n\t\tfloat_clsource.append(source[source.find(\"(\") + 1 : source.rfind(\")\")])\n\tfor node in float_clsources:\n\t\tsource = node.read()\n\t\tfloat_clsource.append(source[source.find(\"(\") + 1 : source.rfind(\")\")])\n\tctx.path.make_node(\"float.cl\").write(''.join(float_clsource))","def test_parallel_dataflow():\n\n if os.path.exists('all.txt'):\n os.remove('all.txt')\n\n # create 5 files with random numbers\n output_files = []\n for i in range(5):\n if os.path.exists('random-%s.txt' % i):\n os.remove('random-%s.txt' % i)\n output_files.append(generate(outputs=[File('random-%s.txt' % i)]))\n\n # concatenate the files into a single file\n cc = concat(inputs=[i.outputs[0]\n for i in output_files], outputs=[File(\"all.txt\")])\n\n # calculate the average of the random numbers\n totals = total(inputs=[cc.outputs[0]])\n print(totals.result())","def main():\n run_test_summary1a()\n run_test_summary1c()\n run_test_summary1c()","def do_stage(self, images):\n\n for i, image in enumerate(images):\n pass\n # logging_tags = logs.image_config_to_tags(image, self.group_by_keywords)","def build(self, manager):\n contents = sorted(self.file_src_dest)\n output_files_dir = self.output_files_dir\n all_dest_files = []\n\n for src_file, dest_file in contents:\n all_dest_files += [dest_file]\n rel = dest_file.relative_to(output_files_dir)\n yield self.task(\n name=f\"copy:{rel}\",\n doc=f\"copy {src_file} to {rel}\",\n file_dep=[src_file],\n targets=[dest_file],\n actions=[\n (self.copy_one, [src_file, dest_file]),\n ],\n )\n\n if manager.source_date_epoch is not None:\n yield self.task(\n name=\"timestamp\",\n file_dep=all_dest_files,\n actions=[\n (self.maybe_timestamp, [self.output_files_dir]),\n ],\n )","def train(self) -> None:\n for module in self.modules.values():\n module.train()\n return","def setup(self):\n for gen in self._generators:\n gen.setup()","def test_4():\n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n identity(in_streams[0], out_streams[0])\n\n def g(in_streams, out_streams):\n multiply(in_streams[0], out_streams[0],\n multiplicand=2)\n\n def h(in_streams, out_streams):\n square(in_streams[0], out_streams[0])\n\n def m(in_streams, out_streams):\n s = Stream('s')\n sum_numbers(in_streams, s)\n print_stream(s, name='s')\n\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n }\n },\n 'multiply_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': g,\n 'sources': {}\n },\n 'square_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': h,\n 'sources': {}\n },\n 'merge_process':\n {'in_stream_names_types': [('in_multiply', 'i'),\n ('in_square', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': m,\n 'sources': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('multiply_process', 'in'), ('square_process', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'multiply_process':\n {\n 'out' : [('merge_process', 'in_multiply')]\n },\n 'square_process':\n {\n 'out' : [('merge_process', 'in_square')]\n },\n 'merge_process':\n {\n }\n }\n\n multicore(processes, connections)","def _run(self):\n self._algorithm(self._list, self)","def run_pending_inits(self, session):\n while self._init_ops:\n session.run(self._init_ops.pop(0))","def _process_datasets_all_frames(self):\n datasets = os.listdir(self.separated_root)\n for dataset in datasets:\n dataset_path = join(self.separated_root, dataset)\n\n for model in self.models:\n\n attacks_list = os.listdir(dataset_path)\n\n for attack in attacks_list:\n attack_path = join(dataset_path, attack)\n\n for prop in self.properties:\n property_alias = prop.get_property_alias()\n\n if os.path.exists(\n join(self.output_features, dataset, attack, property_alias, model.alias)):\n print('%s already extracted features' % dataset)\n continue\n\n path_train = join(attack_path, self.train_alias)\n path_test = join(attack_path, self.test_alias)\n\n X_train, y_train, indexes_train, samples_train = self._get_dataset_contents(path_train,\n property_alias)\n X_test, y_test, indexes_test, samples_test = self._get_dataset_contents(path_test,\n property_alias)\n\n output_features = join(self.output_features, dataset, attack, property_alias, model.alias)\n\n features_train = self._fetch_features(X_train, model, output_features, self.train_alias)\n features_test = self._fetch_features(X_test, model, output_features, self.test_alias)\n\n # saving features\n np.save(join(output_features, (NAME_FEATURES % self.train_alias)), features_train)\n np.save(join(output_features, (NAME_FEATURES % self.test_alias)), features_test)\n\n # saving targets\n np.save(join(output_features, (NAME_TARGETS % self.train_alias)), y_train)\n np.save(join(output_features, (NAME_TARGETS % self.test_alias)), y_test)\n np.save(join(output_features, (NAME_TARGETS % self.test_alias)), y_test)\n\n # saving samples names\n self.__save_txt(join(output_features, (NAME_SAMPLES % self.train_alias)), samples_train)\n self.__save_txt(join(output_features, (NAME_SAMPLES % self.test_alias)), samples_test)","def clean_up(self):\n try:\n data_dir = os.environ[\"DATA\"]\n plots_dir = os.environ[\"PLOTS\"]\n logs_dir = os.environ[\"LOGS\"]\n except KeyError as detail:\n print \"GenerateSpectrum.clean_up: error\", detail, \"not set\"\n print \" --> source analysis environment scripts before running!\"\n sys.exit(1)\n for root, dirs, files in os.walk(os.getcwd()):\n for file in files:\n is_data = re.search(r\".*\\.root$\", file)\n is_plot = re.search(r\".*\\.png$\", file)\n hostname = socket.gethostname()\n is_log = re.search(r\"^rat\\.\"+hostname+r\"\\.[0-9]+\\.log$\", file)\n if is_data:\n try:\n root_file = TFile(file)\n tree = root_file.Get(\"T\")\n tree.ls()\n except ReferenceError as detail:\n \"generate_spectrum.clean_up: error in TFile,\", detail\n sys.exit(1)\n file_manips.copy_file(os.path.join(root, file), data_dir)\n elif is_plot:\n file_manips.copy_file(os.path.join(root, file), plots_dir)\n elif is_log:\n file_manips.copy_file(os.path.join(root, file), logs_dir)","def run(self, sources, task=\"discover\", once=False):\n condition = True\n while condition:\n # list of urls\n self.logger.info(\"Reading source urls from '%s'\" % sources)\n self.__read_sources_doc__(sources)\n # reset url --> destination map. New mappings may be configured\n DestinationMap.__set_map_filename__(Config().\n prop(Config.key_location_mapper_destination_file, \"conf/desmap.txt\"))\n # drop to force fresh read from file\n DestinationMap().__drop__()\n # Set the root of the destination folder if configured\n DestinationMap().set_root_folder(Config().prop(Config.key_destination_root))\n # do all the urls\n self.__do_task__(task)\n # report\n self.__do_report__(task)\n # to continue or not to continue\n condition = not (once or self.__stop__())\n if condition:\n pause = Config().int_prop(Config.key_sync_pause)\n self.logger.info(\"Going to sleep for %d seconds.\" % pause)\n self.logger.debug(\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\")\n time.sleep(pause)\n # repeat after sleep\n condition = not (once or self.__stop__())","def run(self, *args, **kwargs):\n info_list = self._merge()\n self._run(info_list)","def scan(self, sources):\n\t\tself.sources = sources\n\t\tself.start()","def scan(self, sources):\n\t\tself.sources = sources\n\t\tself.start()","def prepare_gen(self, targets):\r\n pass","def run_experiments(data_set=\"\",compact=2,exp_name=\"\",x=\"\"):\n cwd = os.getcwd()\n results_path = cwd+'/data/geometric/'+exp_name+'_'\n dataset_path = cwd+'/data/geometric/'+data_set+'_'\n compact = int(compact)\n if \"m\" in x:\n # make new pxy\n pxy, Xdata, groups = gen_geometric_pxy()\n np.save(dataset_path+'Xdata',Xdata)\n np.save(dataset_path+'groups',groups)\n np.save(dataset_path+'pxy',pxy)\n else:\n # load existing pxy\n pxy = np.load(dataset_path+'pxy.npy')\n if \"r\" in x: # regular experiments\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\n if \"ip\" in x: # initialization experiments - positive p0\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_pos(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_pos.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_pos(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_pos.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_p0_pos(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\n if \"in\" in x: # initialization experiments - negative p0\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_neg(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_neg.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_neg(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_neg.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_p0_neg(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\n if \"c\" in x: # convergence tolerance experiments\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_ctol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_ctol.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_ctol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_ctol.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_ctol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\n if \"z\" in x: # zeroL tolerance experiments\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_zeroLtol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_zeroLtol.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_zeroLtol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_zeroLtol.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_zeroLtol(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\n if \"b\" in x: # trying proposed optimal beta\n if compact>1:\n metrics_stepwise, distributions_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_bestbeta.pkl')\n elif compact>0:\n metrics_stepwise,\\\n metrics_converged, distributions_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\n distributions_converged.to_pickle(results_path+'distributions_converged_bestbeta.pkl')\n else:\n metrics_stepwise,\\\n metrics_converged,\\\n metrics_stepwise_allreps,\\\n metrics_converged_allreps = test_IB(pxy,compact)\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\n return 0","def initialize_sources(self, init_srcs=None, init_src_params=None, photoobj_df=None):\n if init_srcs is not None:\n self.srcs = init_srcs\n elif init_src_params is not None:\n self.srcs = [self._source_type(s, self) for s in init_src_params]\n elif photoobj_df is not None:\n self.srcs = [self._source_type(du.photoobj_to_celestepy_src(p), self)\n for (i, p) in photoobj_df.iterrows()]\n else:\n raise NotImplementedError","def _insertAllSteps(self): \n self.uMics = self.inputCoordinatesTiltedPairs.get().getUntilted().getMicrographs()\n self.tMics = self.inputCoordinatesTiltedPairs.get().getTilted().getMicrographs()\n\n self.inputMics = self._createSetOfParticles('auxMics')\n self.inputMics.copyInfo(self.uMics)\n self.inputMics.setStore(False)\n \n for micU, micT in izip(self.uMics, self.tMics):\n micU.cleanObjId()\n micT.cleanObjId()\n self.inputMics.append(micU)\n self.inputMics.append(micT)\n\n self.samplingInput = self.uMics.getSamplingRate()\n \n\n if self.downsampleType.get() != OTHER:\n # If 'same as picking' or 'original' get sampling rate from input micrographs\n #TODO: Review this when downsampling before picking is possible\n self.samplingFinal = self.samplingInput\n else:\n # If 'other' multiply the input sampling rate by the factor provided\n self.samplingFinal = self.samplingInput*self.downFactor.get()\n \n # Write pos files for each micrograph\n firstStepId = self._insertFunctionStep('writePosFilesStep')\n \n # For each micrograph insert the steps\n #run in parallel\n \n deps = []\n for mic in self.inputMics:\n localDeps = [firstStepId]\n micrographToExtract = mic.getFileName()\n micName = removeBaseExt(mic.getFileName())\n micId = mic.getObjId()\n\n # If downsample type is 'other' perform a downsample\n if self.downsampleType == OTHER:\n fnDownsampled = self._getTmpPath(micName+\"_downsampled.xmp\")\n downFactor = self.downFactor.get()\n args = \"-i %(micrographToExtract)s -o %(fnDownsampled)s --step %(downFactor)f --method fourier\"\n localDeps=[self._insertRunJobStep(\"xmipp_transform_downsample\", args % locals(),prerequisites=localDeps)]\n micrographToExtract = fnDownsampled\n \n # If remove dust \n if self.doRemoveDust:\n fnNoDust = self._getTmpPath(micName+\"_noDust.xmp\")\n \n thresholdDust = self.thresholdDust.get() #TODO: remove this extra variable\n args=\" -i %(micrographToExtract)s -o %(fnNoDust)s --bad_pixels outliers %(thresholdDust)f\"\n localDeps=[self._insertRunJobStep(\"xmipp_transform_filter\", args % locals(),prerequisites=localDeps)]\n micrographToExtract = fnNoDust\n \n #self._insertFunctionStep('getCTF', micId, micName, micrographToExtract)\n micName = removeBaseExt(mic.getFileName())\n \n # Actually extract\n deps.append(self._insertFunctionStep('extractParticlesStep', micId, micName, \n None, micrographToExtract, prerequisites=localDeps))\n # TODO: Delete temporary files\n \n # Insert step to create output objects \n self._insertFunctionStep('createOutputStep', prerequisites=deps)","def do_pass(self, min_ops, transformer):\n assert isinstance(min_ops, Iterable), \"Ops passed into do_pass must be an iterable\"\n has_work = True\n while True:\n if not has_work:\n return\n\n self.replacement_list = []\n\n # pass through the ops in an execution order collecting things to do\n ops = Op.ordered_ops(op.forwarded for op in min_ops)\n for op in ops:\n op.update_forwards()\n self.visit(op)\n\n # Perform the gathered replacements\n for old, rep in self.replacement_list:\n old.forwarded.replace_self(rep.forwarded)\n has_work = len(self.replacement_list) > 0\n min_ops = list(op.forwarded for op in min_ops)","def reset(targets):","def prepare_outer_loop(initial_sampler: InitialSampler,\n initial_log_density: Callable[[Array], Array],\n final_log_density: Callable[[Array], Array],\n flow_func: Callable[[Array], Tuple[Array, Array]],\n config) -> AlgoResultsTuple:\n\n key = jax.random.PRNGKey(config.seed)\n\n flow_forward_fn = hk.without_apply_rng(hk.transform(flow_func))\n key, subkey = jax.random.split(key)\n single_normal_sample = initial_sampler(subkey,\n config.batch_size,\n config.sample_shape)\n key, subkey = jax.random.split(key)\n flow_init_params = flow_forward_fn.init(subkey,\n single_normal_sample)\n\n if config.algo == 'vi':\n opt = optax.adam(config.optimization_config.vi_step_size)\n opt_init_state = opt.init(flow_init_params)\n results = vi.outer_loop_vi(initial_sampler=initial_sampler,\n opt_update=opt.update,\n opt_init_state=opt_init_state,\n flow_init_params=flow_init_params,\n flow_apply=flow_forward_fn.apply,\n key=key,\n initial_log_density=initial_log_density,\n final_log_density=final_log_density,\n config=config)\n elif config.algo == 'smc':\n results = smc.outer_loop_smc(initial_log_density=initial_log_density,\n final_log_density=final_log_density,\n initial_sampler=initial_sampler,\n key=key,\n config=config)\n elif config.algo == 'aft':\n opt = optax.adam(config.optimization_config.aft_step_size)\n opt_init_state = opt.init(flow_init_params)\n # Add a log_step_output function here to enable non-trivial step logging.\n log_step_output = None\n results = aft.outer_loop_aft(opt_update=opt.update,\n opt_init_state=opt_init_state,\n flow_init_params=flow_init_params,\n flow_apply=flow_forward_fn.apply,\n initial_log_density=initial_log_density,\n final_log_density=final_log_density,\n initial_sampler=initial_sampler,\n key=key,\n config=config,\n log_step_output=log_step_output)\n else:\n raise NotImplementedError\n return results","def multiple_eval_for_loops_v2():","def fill_artifacts_at_runtime(self, args):\n for j in self.jobs:\n j.fill_artifacts_at_runtime(args)","def warmup(self, urls: Sequence[str]):\n self._log.info(\"warming up on %d urls\", len(urls))\n for url in urls:\n for analyzer in self._analyzers:\n self._model_repository.get(self._model_id(analyzer), analyzer.model_type, url)","def run_stage_loop(cls, _opts, tests_results, put_next_stage):\n for _, result in tests_results:\n put_next_stage(result)","def update_source_files(source_directory_list, source_extension_list):\n # get source files in the directory list\n source_total = 0\n for unused, source_directory in enumerate(source_directory_list):\n source_files_list = []\n get_requested_files(source_directory, source_extension_list, source_files_list)\n # update the files with shared object references\n for unused, source_file in enumerate(source_files_list):\n updated_file = []\n file_changed = modify_input_file(source_file, updated_file)\n if file_changed:\n filepath = get_printble_filepath(source_file)\n print(filepath)\n source_total += 1\n if __file_update:\n write_output_file(updated_file, source_file)\n print(\"Total Files\", source_total)\n print()","def main(self):\n lines=open(self.expttxt,'r').readlines()\n if self.parall:\n pool=Pool(self.prod)\n pool.map(self.mutatraj,lines)\n pool.close()\n pool.join()\n else:\n for line in lines:\n self.mutatraj(line)","def _init_targets(self):\n for ga_main, ga_targ in zip(self.ga.variables, self.ga_.variables):\n ga_targ.assign(ga_main)\n if self.use_lyapunov:\n for lc_main, lc_targ in zip(self.lc.variables, self.lc_.variables):\n lc_targ.assign(lc_main)\n else:\n for q_1_main, q_1_targ in zip(self.q_1.variables, self.q_1_.variables):\n q_1_targ.assign(q_1_main)\n for q_2_main, q_2_targ in zip(self.q_2.variables, self.q_2_.variables):\n q_2_targ.assign(q_2_main)","def run_experiment(config) -> AlgoResultsTuple:\n log_density_initial = getattr(densities, config.initial_config.density)(\n config.initial_config, config.sample_shape[0])\n log_density_final = getattr(densities, config.final_config.density)(\n config.final_config, config.sample_shape[0])\n initial_sampler = getattr(samplers,\n config.initial_sampler_config.initial_sampler)(\n config.initial_sampler_config)\n\n def flow_func(x):\n if is_flow_algorithm(config.algo):\n flow = getattr(flows, config.flow_config.type)(config.flow_config)\n return jax.vmap(flow)(x)\n else:\n return None\n\n results = prepare_outer_loop(initial_sampler, log_density_initial,\n log_density_final, flow_func, config)\n return results","def execute(self):\n for _ in self:\n pass\n\n return self","def rep(self):\n origin, pipeline_builder = self._get_origin(self.origin)\n destination, pipeline_builder = self._get_destination(self.destination, pipeline_builder)\n pipeline_builder.add_error_stage('Discard')\n\n if self.number_of_processors == 4:\n stream_selector, pipeline_builder = self._get_stream_selector(pipeline_builder)\n expression_evaluator, pipeline_builder = self._get_expression_evaluator(pipeline_builder)\n field_type_converter, pipeline_builder = self._get_field_type_converter(pipeline_builder)\n schema_generator, pipeline_builder = self._get_schema_generator(pipeline_builder)\n trash, pipeline_builder = self._get_destination('Trash', pipeline_builder)\n\n origin >> stream_selector\n stream_selector >> trash\n stream_selector >> expression_evaluator >> field_type_converter >> schema_generator >> destination\n\n stream_selector.condition = [{'outputLane': stream_selector.output_lanes[0],\n 'predicate': '${record:attribute(\"sourceId\") == \"DOESNOTEXIST\"}'},\n {'outputLane': stream_selector.output_lanes[1],\n 'predicate': 'default'}]\n else:\n origin >> destination\n\n for environment in self.environments.values():\n if environment is not None:\n pipeline = pipeline_builder.build().configure_for_environment(environment)\n\n results = self.sdc_executor.benchmark_pipeline(pipeline,\n record_count=self.record_count,\n runs=self.runs)\n\n results['generated_date'] = str(datetime.now())\n results['sdc_version'] = self.sdc_builder.version\n results['origin'] = self.origin\n results['destination'] = self.destination\n results['record_count'] = self.record_count\n results['threads'] = self.number_of_threads\n results['dataset'] = DATASETS[self.dataset]['label']\n results['batch_size'] = self.batch_size\n results['destination_data_format'] = self.destination_format\n results['processor_count'] = self.number_of_processors\n results['cpu_count'] = len(psutil.Process().cpu_affinity())\n results['memory_gb'] = round(psutil.virtual_memory().total / (1000 ** 3))\n try:\n results['instance_type'] = urlopen('http://169.254.169.254/latest/meta-data/instance-type').read().decode('utf-8')\n except (HTTPError, URLError):\n results['instance_type'] = 'unknown'\n\n results['origin_system'] = self.origin_system\n results['destination_system'] = self.destination_system\n\n # Remove outliers\n if len(results['runs']) > 1:\n results['runs'] = [x for x in results['runs'] if -STD_DEV_THRESHOLD < (x - results['throughput_mean']) / results['throughput_std_dev'] < STD_DEV_THRESHOLD]\n results['throughput_mean'] = statistics.mean(results['runs'])\n\n with open(f\"results/{results['pipeline_id']}.json\", \"w\") as file:\n json.dump(results, file)\n\n # Cleanup\n if self.destination == 'Kafka Producer':\n admin_client = KafkaAdminClient(bootstrap_servers=self.environments['cluster'].kafka.brokers, request_timeout_ms=180000)\n admin_client.delete_topics([self.destination_kafka_topic])\n\n if self.destination == 'JDBC Producer':\n self.destination_table.drop(self.environments['database'].engine)\n\n if self.origin == 'HTTP Client':\n self.http_mock.delete_mock()","def sources(self, sources):\n\n self._sources = sources","def reset(self):\n\t\tself.globalQueue = PriorityQueue()\n\t\tself.simTime = 0\n\t\tself.sources = []\n\t\tfor i in range(self.no_of_sources):\n\t\t\t# s = Source(random.random())#, transfer_rate = 4, packet_size = 100, bandwidth = 1000, switch = None)\n\t\t\ts = Source(random.random(), transfer_rate = self.source_tranfer_rate[i], packet_size = 100, bandwidth = self.source_bandwith[i], switch = None)\n\t\t\tself.sources.append(s)\n\t\tself.switch = Switch(output_bandwidth =self.output_bandwidth, source_list = self.sources, queue_size = self.queue_size, sink = None)\n\t\tself.switch.list_sources()\n\t\tself.sink = Sink(switch =self.switch)\n\t\t# connect the sink to the switch\n\t\tself.switch.add_sink(self.sink)\n\t\t# now we need to add the switch to the source\n\t\tfor s in self.sources:\n\t\t\ts.connect_to_switch(self.switch)\n\t\t## all connections have been done\n\t\t# no packets and push into queue_size\n\t\tinitial_events = []\n\t\tfor s in self.sources:\n\t\t\te = s.Produce_Event0(self.simTime)\n\t\t\tinitial_events.append(e)\n\t\t\tself.globalQueue.put(e)","def download_artifacts(self):\n for artifact_set in self._sets:\n for artifact in artifact_set.artifacts:\n artifact.download(self._cache_dir)","def InjectSources(self, sources):\n hydro = integrator.Integrator().hydro\n # Clear values first\n self._totalte = 0.0\n self._totalke = 0.0\n self._totalmass = 0.0\n self._totalphotons = 0.0\n self._sources = sources\n # Add to the input arrays\n for source in sources.sources:\n source.Inject(self)\n # Dump input values onto the grid\n if self._totalmass > 0:\n hydro.mass[0] += self._totalmass\n if self._totalte > 0:\n hydro.TE[0] += self._totalte\n if self._totalke > 0:\n hydro.KE[0] += self._totalke\n if self._totalphotons > 0:\n radiation.trace_radiation(self._totalphotons)\n self._sources = None","def __call__(self, manager=None):\n # set up a reporter\n reporter = reporting.Reporter()\n if self.name is not None:\n prefix = self.name + '/'\n else:\n prefix = ''\n for name, target in self._targets.items():\n reporter.add_observer(prefix + name, target)\n reporter.add_observers(prefix + name,\n target.named_modules())\n\n with reporter:\n with torch.no_grad():\n result = self.evaluate()\n\n reporting.report(result)\n return result","def initialize_single_source(vs, es, s):\n for v in vs:\n v._ss_d = np.inf\n v._ss_pi = None\n v._ss_edge = None\n s._ss_d = 0","def run(self):\n # get components list\n #component_id_list = self.getComponentsList()\n asset_id = 3776\n component_id_list = self.get_component_info_for_one_asset(asset_id)\n # call computeResults method\n results = self.compute_results(component_id_list)\n # write to the output file\n self.write_to_file(results)"],"string":"[\n \"def run(self):\\n\\t\\tfor source in self.sources:\\n\\t\\t\\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\\n\\t\\t\\tfor r in source.get_elements():\\n\\t\\t\\t\\tr.set_source(source)\\n\\t\\t\\t\\tself._queue.put(r)\\n\\n\\t\\t\\t\\t# Extra tracking stuff below:\\n\\t\\t\\t\\twith self._c_lock:\\n\\t\\t\\t\\t\\tself._total_count+= 1\\n\\t\\t\\t\\tif self._testing_cache is not None:\\n\\t\\t\\t\\t\\tself._testing_cache.append(r)\\n\\t\\t#print(\\\"Element loading complete.\\\\n\\\")\\n\\t\\tself._running = False\",\n \"def run(self):\\n\\t\\tself._keep_running = True\\n\\t\\tif self._testing_cache is not None:\\n\\t\\t\\tself._testing_cache = []\\n\\n\\t\\tfor source in self.sources:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\\n\\t\\t\\t\\tfor r in source.get_elements():\\n\\t\\t\\t\\t\\tif not self._keep_running:\\n\\t\\t\\t\\t\\t\\treturn\\n\\t\\t\\t\\t\\tr.set_source(source)\\n\\t\\t\\t\\t\\twhile self._keep_running:\\n\\t\\t\\t\\t\\t\\ttry: # Keep trying to add this element to the queue, with a timeout to catch any stop triggers.\\n\\t\\t\\t\\t\\t\\t\\tself._queue.put(r, timeout=1)\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\texcept queue.Full:\\n\\t\\t\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\t\\t# Extra tracking stuff below:\\n\\t\\t\\t\\t\\twith self._c_lock:\\n\\t\\t\\t\\t\\t\\tself._total_count += 1\\n\\t\\t\\t\\t\\tif self._testing_cache is not None:\\n\\t\\t\\t\\t\\t\\tself._testing_cache.append(r)\\n\\t\\t\\texcept ConnectionError as ce:\\n\\t\\t\\t\\tprint(str(ce).upper())\\n\\t\\tself._keep_running = False\",\n \"def runall(sources='sources'):\\n init()\\n upload_sources(sources)\\n compile()\\n run()\",\n \"def __call__(self, images, targets):\\n pass\",\n \"def run_all(operations=ops):\\n for operation in operations:\\n run(operation)\",\n \"def execute(self, targets):\",\n \"def run(self):\\n count = self.neuron_count\\n for i in range(0, count):\\n self.run(i)\",\n \"def update(self):\\n with enforce_unique_instance('repository', blocking=True):\\n for dist, component in self.pending:\\n self.update_sources(dist, component)\",\n \"def run(self):\\n for tool in self.tools:\\n tool.run()\\n return\",\n \"def run(layers):\",\n \"def main() -> co.Parallel:\\n actors = [\\\"Oprah Winfrey\\\", \\\"Kate Mara\\\", \\\"Don Cheadle\\\", \\\"Dwayne Johnson\\\"]\\n root = co.Parallel(image=_get_image())\\n for actor in actors:\\n root[actor] = co.Lazy(\\n f\\\"python pipeline.py all_by_actor '{actor}'\\\"\\n )\\n return root\",\n \"def sync(self):\\n if (len(self._source_list) == 0) or (len(self._dest_list) == 0):\\n return\\n \\n for src in self._source_list:\\n self._sync('.', src, self._depth)\",\n \"def run(self):\\n self.assign_inputs()\\n self.execute()\\n self.collect_outputs()\",\n \"def update_all_sources(source_data_filename, host_filename):\\n\\n # The transforms we support\\n transform_methods = {\\\"jsonarray\\\": jsonarray}\\n\\n all_sources = sort_sources(recursive_glob(\\\"*\\\", source_data_filename))\\n\\n for source in all_sources:\\n update_file = open(source, \\\"r\\\", encoding=\\\"UTF-8\\\")\\n update_data = json.load(update_file)\\n update_file.close()\\n\\n # we can pause updating any given hosts source.\\n # if the update.json \\\"pause\\\" key is missing, don't pause.\\n if update_data.get('pause', False):\\n continue\\n\\n update_url = update_data[\\\"url\\\"]\\n update_transforms = []\\n if update_data.get(\\\"transforms\\\"):\\n update_transforms = update_data[\\\"transforms\\\"]\\n\\n print(\\\"Updating source \\\" + os.path.dirname(source) + \\\" from \\\" + update_url)\\n\\n try:\\n updated_file = get_file_by_url(update_url)\\n\\n # spin the transforms as required\\n for transform in update_transforms:\\n updated_file = transform_methods[transform](updated_file)\\n\\n # get rid of carriage-return symbols\\n updated_file = updated_file.replace(\\\"\\\\r\\\", \\\"\\\")\\n\\n hosts_file = open(\\n path_join_robust(BASEDIR_PATH, os.path.dirname(source), host_filename),\\n \\\"wb\\\",\\n )\\n write_data(hosts_file, updated_file)\\n hosts_file.close()\\n except Exception:\\n print(\\\"Error in updating source: \\\", update_url)\",\n \"def _load_sources(self):\\n self.point_sources= []\\n if os.path.exists(os.path.join(self.folder,'pickle.zip')):\\n pzip = zipfile.ZipFile(os.path.join(self.folder,'pickle.zip'))\\n files = ['pickle/HP12_%04d.pickle' %i for i in range(1728)]\\n assert all(f in pzip.namelist() for f in files), 'Improper model zip file'\\n opener = pzip.open\\n else:\\n files = glob.glob(os.path.join(self.folder, 'pickle', '*.pickle'))\\n files.sort()\\n opener = open\\n self.nside = int(np.sqrt(len(files)/12))\\n if len(files) != 12*self.nside**2:\\n msg = 'Number of pickled ROI files, %d, found in folder %s, not consistent with HEALpix' \\\\\\n % (len(files),os.path.join(self.folder, 'pickle'))\\n raise Exception(msg)\\n \\n ####self.global_sources = sources.GlobalSourceList() # allocate list to index parameters for global sources\\n self.extended_sources=[] # list of unique extended sources\\n self.changed=set() # to keep track of extended models that are different from catalog\\n moved=0\\n nfreed = 0\\n self.tagged=set()\\n source_names =[]\\n for i,file in enumerate(files):\\n p = pickle.load(opener(file))\\n index = int(os.path.splitext(file)[0][-4:])\\n assert i==index, 'logic error: file name %s inconsistent with expected index %d' % (file, i)\\n roi_sources = p.get('sources', {}) # don't know why this needed\\n extended_names = {} if (self.__dict__.get('extended_catalog') is None) else self.extended_catalog.names\\n for key,item in roi_sources.items():\\n if key in extended_names: continue\\n if key in source_names:\\n #if not self.quiet: print ('SkyModel warning: source with name %s in ROI %d duplicates previous entry: ignored'%(key, i))\\n continue\\n source_names.append(key)\\n skydir = item['skydir']\\n if self.update_positions is not None:\\n ellipse = item.get('ellipse', None)\\n ts = item['ts']\\n if ellipse is not None and not np.any(np.isnan(ellipse)) :\\n fit_ra, fit_dec, a, b, ang, qual, delta_ts = ellipse\\n if qual<5 and a < 0.2 and \\\\\\n ts>self.update_positions and delta_ts>0.1:\\n skydir = SkyDir(float(fit_ra),float(fit_dec))\\n moved +=1\\n self.tagged.add(i)\\n \\n ps = sources.PointSource(name=key,\\n skydir=skydir, model= sources.convert_model(item['model']),\\n ts=item['ts'],band_ts=item['band_ts'], index=index)\\n if sources.validate(ps,self.nside, self.filter):\\n self._check_position(ps) # check that it is not coincident with previous source(warning for now?)\\n self.point_sources.append( ps)\\n # make a list of extended sources used in the model \\n names = p.get('diffuse_names')\\n for name, oldmodel in zip(names, p['diffuse']):\\n model = sources.convert_model(oldmodel) # convert from old Model version if necessary \\n key = name.split('_')[0]\\n if key in self.diffuse_dict:\\n self.diffuse_dict.add_model(index, name, model)\\n elif self.extended_catalog_name=='ignore': \\n continue\\n else:\\n try:\\n es = self.extended_catalog.lookup(name) if self.extended_catalog is not None else None\\n except Exception as msg:\\n print ('Skymodel: Failed to create model for %s' %name)\\n raise\\n if es is None:\\n #raise Exception( 'Extended source %s not found in extended catalog' %name)\\n print ('SkyModel warning: Extended source %s not found in extended catalog, removing' %name)\\n continue\\n if self.hpindex(es.skydir)!=index: continue\\n \\n if es.model.name!=model.name:\\n if name not in self.changed:\\n if not self.quiet: print ('SkyModel warning: catalog model %s changed from %s for source %s: keeping change'%\\\\\\n (es.model.name, model.name, name))\\n self.changed.add(name)\\n es.smodel=es.model=model #update with current fit values always\\n if sources.validate(es,self.nside, self.filter): #lambda x: True): \\n self.extended_sources.append(es)\\n # check for new extended sources not yet in model\\n self._check_for_extended()\\n if self.update_positions and moved>0:\\n print ('updated positions of %d sources, healpix ids in tagged' % moved)\",\n \"def calculator_build_events_from_sources(self):\\n gsims_by_trt = self.calculator.csm.full_lt.get_gsims_by_trt()\\n print('FetchOpenQuake: self.calculator.csm.src_groups = ')\\n print(self.calculator.csm.src_groups)\\n sources = self.calculator.csm.get_sources()\\n print('FetchOpenQuake: sources = ')\\n print(sources)\\n for src in sources:\\n src.nsites = 1 # avoid 0 weight\\n src.num_ruptures = src.count_ruptures()\\n maxweight = sum(sg.weight for sg in self.calculator.csm.src_groups) / (\\n self.calculator.oqparam.concurrent_tasks or 1)\\n print('FetchOpenQuake: weights = ')\\n print([sg.weight for sg in self.calculator.csm.src_groups])\\n print('FetchOpenQuake: maxweight = ')\\n print(maxweight)\\n eff_ruptures = general.AccumDict(accum=0) # trt => potential ruptures\\n calc_times = general.AccumDict(accum=np.zeros(3, np.float32)) # nr, ns, dt\\n allargs = []\\n if self.calculator.oqparam.is_ucerf():\\n # manage the filtering in a special way\\n for sg in self.calculator.csm.src_groups:\\n for src in sg:\\n src.src_filter = self.calculator.srcfilter\\n srcfilter = calc.filters.nofilter # otherwise it would be ultra-slow\\n else:\\n srcfilter = self.calculator.srcfilter\\n logging.info('Building ruptures')\\n for sg in self.calculator.csm.src_groups:\\n if not sg.sources:\\n continue\\n logging.info('Sending %s', sg)\\n par = self.calculator.param.copy()\\n par['gsims'] = gsims_by_trt[sg.trt]\\n for src_group in sg.split(maxweight):\\n allargs.append((src_group, srcfilter, par))\\n\\n smap = [] \\n for curargs in allargs:\\n smap.append(calc.stochastic.sample_ruptures(curargs[0], curargs[1], curargs[2]))\\n\\n print('smap = ')\\n print(smap)\\n self.calculator.nruptures = 0\\n mon = self.calculator.monitor('saving ruptures')\\n for tmp in smap:\\n dic = next(tmp)\\n print(dic)\\n # NB: dic should be a dictionary, but when the calculation dies\\n # for an OOM it can become None, thus giving a very confusing error\\n if dic is None:\\n raise MemoryError('You ran out of memory!')\\n rup_array = dic['rup_array']\\n if len(rup_array) == 0:\\n continue\\n if dic['calc_times']:\\n calc_times += dic['calc_times']\\n if dic['eff_ruptures']:\\n eff_ruptures += dic['eff_ruptures']\\n with mon:\\n n = len(rup_array)\\n rup_array['id'] = np.arange(\\n self.calculator.nruptures, self.calculator.nruptures + n)\\n self.calculator.nruptures += n\\n hdf5.extend(self.calculator.datastore['ruptures'], rup_array)\\n hdf5.extend(self.calculator.datastore['rupgeoms'], rup_array.geom)\\n\\n if len(self.calculator.datastore['ruptures']) == 0:\\n raise RuntimeError('No ruptures were generated, perhaps the '\\n 'investigation time is too short')\\n\\n # must be called before storing the events\\n self.calculator.store_rlz_info(eff_ruptures) # store full_lt\\n self.calculator.store_source_info(calc_times)\\n imp = commonlib.calc.RuptureImporter(self.calculator.datastore)\\n print('self.calculator.datastore.getitem(ruptures)')\\n print(self.calculator.datastore.getitem('ruptures'))\\n with self.calculator.monitor('saving ruptures and events'):\\n imp.import_rups_events(self.calculator.datastore.getitem('ruptures')[()], getters.get_rupture_getters)\",\n \"def all(source=None):\\n package(source)\\n deploy()\",\n \"def run(self):\\r\\n for pipe in self.inputs:\\r\\n for row in pipe.rows():\\r\\n self.put(row)\",\n \"def warmup_one_iter(self) -> None:\\n self.model.eval()\\n for batch_data in self.testloader:\\n images, labels = (\\n batch_data[0].to(self.device),\\n batch_data[1].to(self.device),\\n )\\n\\n # forward + backward + optimize\\n loss, outputs = self.criterion(\\n model=self.model, images=images, labels=labels\\n )\\n return None\",\n \"def query_initial_sources(self):\\n self.search_thread_pool.waitForDone(0)\\n # self.init_vector_layers()\\n username, password, api_key, max_items_to_return = SettingsOps.get_settings()\\n errors = []\\n SettingsOps.validate_stored_info(username, password, api_key, max_items_to_return, errors)\\n if len(errors) == 0:\\n source_runnable = SourceRunnable(username, password, api_key, DEFAULT_ORDER_PARAMS)\\n source_runnable.source_object.task_complete.connect(self.on_new_source)\\n self.init_progress_bar()\\n self.search_thread_pool.start(source_runnable)\",\n \"def __call__(self, images, targets):\\n return images, targets\",\n \"def main(unused_argv):\\n make_dir(FLAGS.raw_dir)\\n\\n # Get paths of download/extracted training and evaluation files.\\n print(\\\"Downloading data from source\\\")\\n train_files = get_raw_files(FLAGS.raw_dir, constants.TRAIN_DATA_SOURCES)\\n eval_files = get_raw_files(FLAGS.raw_dir, constants.EVAL_DATA_SOURCES)\",\n \"def process(self, args):\\n for benchmark_file in args.benchmark_files:\\n self.process_individual_file(benchmark_file)\\n self.total_files += 1\",\n \"def resolve_components(self) -> None:\\n for mix in self:\\n if not isinstance(mix, Mix):\\n continue\\n mix.with_experiment(self, True)\",\n \"def run_all_layers(self, img): # noqa\\n s1_outputs = [s1(img) for s1 in self.s1_units]\\n\\n # Each C1 layer pools across two S1 layers\\n c1_outputs = []\\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\\n c1_outputs.append(c1(s1_outputs[i:i+2]))\\n\\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\\n\\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs\",\n \"def runall():\\n sclogic.runall()\",\n \"def AutoQuakePycker_run():\\n import glob\\n from itertools import product\\n import multiprocessing\\n import logging\\n import more_itertools as mit\\n from munch import munchify\\n import os\\n import yaml\\n from obspy import read_events, Catalog\\n\\n logger = multiprocessing.log_to_stderr(logging.DEBUG)\\n # Read in config file\\n with open(\\\"config.yaml\\\", \\\"r\\\") as ymlfile:\\n cfg = munchify(yaml.safe_load(ymlfile))\\n initial_cat = read_events(cfg.input.lassie_cat_file)\\n\\n # Read in station locations from file\\n sta_list = [[l.split()[1], float(l.split()[3]), float(l.split()[4])] for l\\n in open(\\\"NLLOC_run/run.in\\\", \\\"r\\\") if l.split()[0] == \\\"GTSRCE\\\"]\\n sta_locs = {sta[0]: {\\\"lat\\\": sta[1], \\\"lon\\\": sta[2]} for sta in sta_list}\\n if cfg.output.FORCE_RECALC is True:\\n filelist = glob.glob(os.path.join(\\\"refined_events\\\", \\\"*.xml\\\"))\\n for f in filelist:\\n os.remove(f)\\n if cfg.run.nproc == \\\"auto\\\":\\n nproc = multiprocessing.cpu_count()\\n else:\\n nproc = cfg.run.nproc\\n # Get events for which data currently is available\\n cat_filter = Catalog()\\n for n, event in enumerate(initial_cat):\\n e_id = event.event_descriptions[0].text\\n if e_id in os.listdir(\\\"{:}/\\\".format(cfg.input.DIR_TO_EVENTDIRS)):\\n if (cfg.output.FORCE_RECALC is False and\\n os.path.exists(\\\"refined_events/{:}.xml\\\".format(e_id))):\\n print(\\\"Already have this evening ... skipping\\\")\\n else:\\n cat_filter.append(event)\\n # Split catalogue across multiple processes and process in parallel\\n cat_split = [i for i in mit.divide(nproc, cat_filter)]\\n # process_events(cat_split[7], 7)\\n pool = multiprocessing.Pool(processes=nproc)\\n print(\\\"hello\\\")\\n a = pool.starmap(process_events, product(cat_split, range(nproc), cfg,\\n sta_locs))\\n\\n logger.debug(a)\",\n \"def bulk_train(self):\\n logger.info(\\\"collecting subfolders - relations\\\")\\n relations = self.collect_subfolders(self.input_dir)\\n logger.info(\\\"relations - {}\\\".format(relations))\\n\\n execution_times = []\\n\\n for rel, rel_path in tqdm(relations.items(), desc=\\\"relations\\\"):\\n logger.info(\\\"collecting training files from {}\\\".format(rel_path))\\n tr_files = self.collect_files(rel_path, self.regexp_train)\\n hyper_params = self.get_hyperparams()\\n hyper_params['graph'] = tr_files\\n\\n output_folder = os.path.join(self.output_dir, rel)\\n if not os.path.exists(output_folder):\\n logger.info(\\\"creating {} (did not exist)\\\".format(output_folder))\\n os.makedirs(output_folder)\\n\\n for params in tqdm(ParameterGrid(hyper_params), desc=\\\"training embedding\\\"):\\n logger.info(\\\"hyperparams: {}\\\".format(params))\\n train_file = params['graph']\\n model_name = self.compute_model_name(params, output_folder)\\n logger.info('training starspace model \\\"{}\\\" from file \\\"{}\\\"'.format(\\n model_name, train_file))\\n external_output, delta = self.call_starspace(params, train_file, model_name)\\n logger.info(\\\"executed in {:0.2f}s\\\".format(delta))\\n\\n logger.info(\\\"external command output logged in {}\\\".format(self.external_log))\\n if not os.path.exists(self.output_dir):\\n logger.info(\\\"creating {} (did not exist)\\\".format(self.output_dir))\\n os.makedirs(self.output_dir)\\n\\n with open(self.external_log, 'a') as f:\\n f.write(external_output)\\n\\n execution_times.append(dict({ 'time': delta }, **params))\\n \\n return execution_times\",\n \"def __init__(self, sources, folder):\\r\\n # TODO: include possibility of multiple aggregating functions?\\r\\n self._acc = folder\\r\\n if type(sources) is not list:\\r\\n sources = [sources]\\r\\n\\r\\n self._sources = sources\\r\\n for k in range(len(sources)):\\r\\n if type(sources[k]) == type(self):\\r\\n sources[k] = OnEveryDt(1, sources[k])\\r\\n self._events = [event.subscribe(source, _(self)._update, self) for source in self._sources]\",\n \"def process_images(self):\\n source_images = self.get_build_images()\\n self.log.info(\\\"Got %s images for publishing. Processing..\\\", len(source_images))\\n\\n for image in source_images:\\n self.fetch_image(image)\\n\\n for target in image.push_registries:\\n for tag in image.release_tags:\\n repository = \\\"%s/%s\\\" % (target, image.repository.name)\\n self.tag_image(image, repository, tag)\\n retry_count = 1\\n while retry_count <= self.retry_limit:\\n self.log.info(\\\"Pushing %s:%s to %s (%d/%d)\\\", repository, tag, target, retry_count, self.retry_limit)\\n try:\\n self.publish_image(target, repository, tag)\\n break\\n except ImagePushError as e:\\n self.log.error(\\\"%s\\\", e.message)\\n retry_count = retry_count + 1\\n else:\\n return False\\n return True\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def test_3():\\n \\n\\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n multiply_and_add(in_streams[0], out_streams[0],\\n multiplicand=2, addend=1)\\n\\n def g(in_streams, out_streams):\\n t = Stream('t')\\n filter_then_square(in_streams[0], t,\\n filter_threshold=20)\\n print_stream(t, name='p1')\\n\\n def sums(in_streams, out_streams):\\n s = Stream('s')\\n sum_window(in_streams[0], s, window_size=3, step_size=3)\\n print_stream(s, name=' p2')\\n\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n }\\n },\\n 'process_1':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': g,\\n 'sources': {}\\n },\\n 'process_2':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': sums,\\n 'sources': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'process_1':\\n {\\n },\\n 'process_2':\\n {\\n }\\n }\\n\\n multicore(processes, connections)\",\n \"def multi_run_wrapper(args):\\n\\treturn img_preprocessing(*args)\",\n \"def run():\\n\\n today = datetime.now().strftime(\\\"%Y-%m-%d\\\")\\n log_file = os.path.abspath(\\\"logs/{}.log\\\".format(today))\\n logger = RsmasLogger(\\\"pipeline\\\", log_file)\\n\\n images = get_list_of_images()\\n # LOG: list of images to process\\n logger.log(loglevel.INFO, [img.key for img in images])\\n\\n for im in images:\\n\\n logger.log(loglevel.INFO, \\\"Processing image: {}\\\".format(im.key))\\n\\n file_path = \\\"{}/{}\\\".format(im.bucket_name, im.key)\\n full_path = \\\"{}_full.jpg\\\"\\n mod_path = \\\"{}_mod.jpg\\\"\\n aws_path = \\\"{}/{}/{}/{}\\\"\\n try:\\n haz_id, haz_name, sat_name, sat_dir, img_type, img_date, center = summary.pull_summary_data(\\n \\\"/vsis3/{}\\\".format(file_path))\\n sat_id = Satellite.from_params(sat_name, bool(sat_dir))\\n except:\\n # LOG: error in image metadata format\\n logger.log(loglevel.ERROR, '\\\\tThere was an error in the metadata format of the image. Skipping.')\\n continue\\n\\n aws_path = aws_path.format(haz_id, sat_id, img_type, img_date)\\n full_path = full_path.format(img_date)\\n mod_path = mod_path.format(img_date)\\n\\n # 1. Read in image file\\n with rasterio.open(\\\"s3://{}\\\".format(file_path)) as data:\\n band = data.read(1)\\n img = plot.show(band)\\n img.get_figure().savefig(full_path, dpi=300)\\n\\n # 3. Compress image\\n compressed = immanip.compress_image(full_path, compression_amount=0.3)\\n\\n # 4 - 5. Pad image and add date on image\\n text_image = immanip.add_text_to_image(compressed, img_date)\\n\\n # 6. Save image locally\\n text_image.save(mod_path.format(img_date))\\n mod_path_aws = save.get_s3_url(\\\"{}/{}\\\".format(aws_path, mod_path))\\n full_path_aws = save.get_s3_url(\\\"{}/{}\\\".format(aws_path, full_path))\\n\\n tif_path_aws = save.get_s3_url(\\\"{}/{}\\\".format(aws_path, im.key))\\n\\n # LOG: images successfully moved to S3 bucket\\n # LOG: mod_path_aws, full_path_aws, tif_path_aws\\n\\n hazard = Hazard(haz_id, haz_name, HazardType.VOLCANO, Location(center[0], center[1]), Date(img_date), 0)\\n satellite = Satellite.from_params(sat_name, bool(sat_dir))\\n image = Image(str(randint(1, 10000000)),\\n haz_id,\\n satellite,\\n ImageType.from_string(img_type),\\n Date(img_date),\\n ImageURL(full_path_aws),\\n ImageURL(tif_path_aws),\\n ImageURL(mod_path_aws))\\n\\n try:\\n db = Database()\\n except ConnectionError:\\n logger.log(loglevel.ERROR, \\\"\\\\tThere was an error while connecting to the database. Skipping this image.\\\")\\n continue\\n\\n db.create_new_hazard(hazard)\\n db.create_new_satellite(satellite)\\n db.create_new_image(image)\\n\\n db.close()\\n\\n # LOG: database successfully updated\\n logger.log(loglevel.INFO, \\\"\\\\tDatabase succesfully updated.\\\")\\n\\n save.save_image_s3(mod_path, \\\"{}/{}\\\".format(aws_path, mod_path))\\n save.save_image_s3(full_path, \\\"{}/{}\\\".format(aws_path, full_path))\\n save.move_tif(im.key, \\\"{}/{}\\\".format(aws_path, im.key))\\n\\n logger.log(loglevel.INFO, \\\"\\\\tImages were successfully uploaded to the S3 bucket\\\")\\n logger.log(loglevel.INFO, \\\"\\\\t\\\\tmod_path_aws: {}\\\".format(mod_path_aws))\\n logger.log(loglevel.INFO, \\\"\\\\t\\\\tfull_path_aws: {}\\\".format(full_path_aws))\\n logger.log(loglevel.INFO, \\\"\\\\t\\\\ttif_path_aws: {}\\\".format(tif_path_aws))\\n\\n # LOG: image completed\\n logger.log(loglevel.INFO, \\\"\\\\tProcessing of {} completed.\\\".format(im.key))\\n\\n # LOG: finished processing images\\n logger.log(loglevel.INFO, \\\"Processing complete.\\\")\",\n \"def reduce_run():\",\n \"def _iterate_over_files(self):\\n stats = Statistics()\\n\\n args = arguments.Args()\\n\\n for file in args.files:\\n\\n if isimage(file):\\n before_size = stats.calculate_before_optimization(file)\\n\\n puts(\\\"%s %s\\\" % (\\n e(\\\"==>\\\"),\\n os.path.basename(file))\\n )\\n\\n if \\\"--lossy\\\" in args.flags:\\n Optimize.lossy(file)\\n if \\\"--lossless\\\" in args.flags:\\n Optimize.lossless(file)\\n after_size = stats.calculate_after_optimization(file)\\n\\n puts(\\\"%s %s (%s)\\\" % (\\n p(\\\"<==\\\"),\\n os.path.basename(file),\\n s(after_size) if after_size < before_size else after_size\\n ))\\n\\n stats.show_statistics()\",\n \"def __init__(self):\\n self.train(positivity_files, 0)\\n self.train(subjectivity_files, 1)\",\n \"def compute(self, inputs, outputs):\\n\\n log.info(f\\\"Start optimisation iteration: {Rt.counter}\\\")\\n\\n # Update the geometry dictionary\\n for name, infos in Rt.geom_dict.items():\\n infos[1].append(inputs[name][0])\\n\\n if Rt.counter == 0:\\n\\n # For the first iteration, update the CPACS file from previous module\\n cpacs_in = Rt.modules[0].cpacs_in\\n cpacs_out = Rt.modules[0].cpacs_out\\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\\n\\n else:\\n\\n for m, module in enumerate(Rt.modules):\\n\\n # Increment name of output CPACS file\\n Rt.modules[m].cpacs_out = Path(\\n Rt.modules[m].cpacs_out.parents[0],\\n \\\"iter_\\\" + str(Rt.counter).rjust(2, \\\"0\\\") + \\\".xml\\\",\\n )\\n\\n if m == 0:\\n\\n # Use output of the last module of the previous iteration as input\\n Rt.modules[m].cpacs_in = Rt.modules[-1].cpacs_out\\n\\n # Update the geometry of the CPACS file\\n cpacs_in = Rt.modules[m].cpacs_in\\n cpacs_out = Rt.modules[m].cpacs_out\\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\\n\\n # # The first module of the loop must update its output where the input\\n # # was saved because it has been updated by \\\"update_cpacs_file\\\" function.\\n # Rt.modules[m].cpacs_in = Rt.modules[m].cpacs_out\\n\\n else:\\n\\n # Increment name of input CPACS file\\n Rt.modules[m].cpacs_in = Path(\\n Rt.modules[m].cpacs_in.parents[0],\\n \\\"iter_\\\" + str(Rt.counter).rjust(2, \\\"0\\\") + \\\".xml\\\",\\n )\\n\\n Rt.counter += 1\",\n \"async def dispatch_auto_starts(self, ctx):\\n for operation in self.config.dataflow.operations.values():\\n if operation.inputs or not await self.ictx.check_conditions(\\n operation, self.config.dataflow, ctx\\n ):\\n continue\\n parameter_set = MemoryParameterSet(\\n MemoryParameterSetConfig(ctx=ctx, parameters=[])\\n )\\n task = await self.nctx.dispatch(self, operation, parameter_set)\\n task.operation = operation\\n task.parameter_set = parameter_set\\n yield task\",\n \"def execute(self, images_and_density_maps):\\n # these imports are used in eval(), don't remove them\\n import CCAugmentation.outputs as cca_out\\n import CCAugmentation.transformations as cca_trans\\n _ = cca_out, cca_trans\\n\\n op_str = self._get_op_str()\\n const_str = self._get_const_str()\\n\\n for image_and_density_map in images_and_density_maps:\\n rand_str = self._get_rand_str()\\n args_str = \\\",\\\".join([const_str, rand_str]) if const_str and rand_str else const_str + rand_str\\n op = eval(f\\\"{op_str}({args_str})\\\")\\n for result in op.execute([image_and_density_map]):\\n yield result\",\n \"def prepare(self) -> None:\\n for name, step, kwargs in self.steps:\\n self.stream = step(self.stream, **kwargs)\",\n \"def run_multiple_test_cycles(self):\\n # Perform as many cycles as required\\n while self.args.repetitions >= 0:\\n self.run_one_test_cycle()\\n self.args.repetitions -= 1\",\n \"def load_files_to_compare(self):\\n self.first_source_data = load_path(self.path1)\\n self.second_source_data = load_path(self.path2)\",\n \"def run(self, inputs):\\n for layer in self._layers:\\n inputs = layer.calc(inputs)\\n return inputs\",\n \"def gen_stage_loop(cls, _opts, tests, put_next_stage, _put_result_stage):\\n for test in tests:\\n put_next_stage(test)\",\n \"def run(self, *args, **kwargs) -> None:\\n loop = tqdm(self.configs, desc='Configurations')\\n for cfg in loop:\\n loop.set_postfix_str(cfg.experiment_cfg['name'])\\n for i in range(cfg.num_models):\\n filename = None\\n run_id = None\\n if cfg.filenames is not None:\\n if isinstance(cfg.filenames, str):\\n filename = cfg.filenames\\n else:\\n filename = cfg.filenames[i]\\n elif cfg.run_ids is not None:\\n run_id = cfg.run_ids[i]\\n\\n run_cfg = modelgen_cfg_to_runner_cfg(cfg, run_id=run_id, filename=filename)\\n runner = Runner(run_cfg, persist_metadata=cfg.experiment_cfg)\\n runner.run()\\n\\n # clear up memory between runs\\n torch.cuda.empty_cache()\",\n \"def Run(self):\\n # get the runs object, which is an index for every tag.\\n runs = self.GetRouteAndSave('runs')\\n\\n # collect sampled data.\\n self.GetRouteAndSave('scalars')\\n\\n # now let's just download everything!\\n for run, tag_type_to_tags in six.iteritems(runs):\\n for tag_type, tags in six.iteritems(tag_type_to_tags):\\n try:\\n if tag_type == 'graph':\\n # in this case, tags is a bool which specifies if graph is present.\\n if tags:\\n url = Url('graph', {'run': run})\\n self.GetAndSave(url, GRAPH_SUFFIX, unzip=True)\\n elif tag_type == 'images':\\n for t in tags:\\n images = self.GetRouteAndSave('images', {'run': run, 'tag': t})\\n for im in images:\\n url = 'individualImage?' + im['query']\\n # pull down the images themselves.\\n self.GetAndSave(url, IMAGE_SUFFIX)\\n elif tag_type == 'audio':\\n for t in tags:\\n audio = self.GetRouteAndSave('audio', {'run': run, 'tag': t})\\n for snd in audio:\\n url = 'individualAudio?' + snd['query']\\n # pull down the audio clips themselves\\n self.GetAndSave(url, AUDIO_SUFFIX)\\n elif tag_type == 'run_metadata':\\n for t in tags:\\n url = Url('run_metadata', {'run': run, 'tag': t})\\n self.GetAndSave(url, GRAPH_SUFFIX, unzip=True)\\n elif tag_type == 'firstEventTimestamp':\\n pass\\n else:\\n for t in tags:\\n # Save this, whatever it is :)\\n self.GetRouteAndSave(tag_type, {'run': run, 'tag': t})\\n except IOError as e:\\n PrintAndLog('Retrieval failed for %s/%s/%s' % (tag_type, run, tags),\\n tf.logging.WARN)\\n PrintAndLog('Got Exception: %s' % e, tf.logging.WARN)\\n PrintAndLog('continuing...', tf.logging.WARN)\\n continue\",\n \"def test_multi_source_explicit(self):\\n with Graph('g') as graph:\\n graph.source | Node('a') | graph.sink\\n graph.source * 'out2' | Node('b') | 'in2' * graph.sink\",\n \"def test_2():\\n \\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n multiply_and_add(in_streams[0], out_streams[0],\\n multiplicand=2, addend=1)\\n\\n def g(in_streams, out_streams):\\n filter_then_square(in_streams[0], out_streams[0],\\n filter_threshold=20)\\n\\n def h(in_streams, out_streams):\\n s = Stream('s')\\n sum_window(in_streams[0], s, window_size=3, step_size=3)\\n print_stream(s, name=s.name)\\n \\n\\n # Specify processes and connections.\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n },\\n 'actuators': {}\\n },\\n 'filter_and_square_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('filtered', 'i')],\\n 'compute_func': g,\\n 'sources': {},\\n 'actuators': {}\\n },\\n 'aggregate_and_output_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': h,\\n 'sources': {},\\n 'actuators': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('filter_and_square_process', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'filter_and_square_process' :\\n {\\n 'filtered' : [('aggregate_and_output_process', 'in')],\\n },\\n 'aggregate_and_output_process':\\n {}\\n }\\n\\n multicore(processes, connections)\",\n \"def _threaded(self, *args, **kwargs):\\n\\n for target in self.targets:\\n result = target(*args, **kwargs)\\n self.queue.put(result)\",\n \"def readSources(self):\\n for sourceCount, sourceElement in enumerate(self.root.findall(\\\".sources/source\\\")):\\n # shall we just read the UFO here?\\n filename = sourceElement.attrib.get('filename')\\n # filename is a path relaive to the documentpath. resolve first.\\n sourcePath = os.path.abspath(os.path.join(os.path.dirname(self.path), filename))\\n sourceName = sourceElement.attrib.get('name')\\n if sourceName is None:\\n # if the source element has no name attribute\\n # (some authoring tools do not need them)\\n # then we should make a temporary one. We still need it for reference.\\n sourceName = \\\"temp_master.%d\\\"%(sourceCount)\\n self.reportProgress(\\\"prep\\\", 'load', sourcePath)\\n if not os.path.exists(sourcePath):\\n raise MutatorError(\\\"Source not found at %s\\\"%sourcePath)\\n sourceObject = self._instantiateFont(sourcePath)\\n # read the locations\\n sourceLocationObject = None\\n sourceLocationObject = self.locationFromElement(sourceElement)\\n\\n if sourceLocationObject is None:\\n raise MutatorError(\\\"No location defined for source %s\\\"%sourceName)\\n\\n # read lib flag\\n for libElement in sourceElement.findall('.lib'):\\n if libElement.attrib.get('copy') == '1':\\n self.libSource = sourceName\\n\\n # read the groups flag\\n for groupsElement in sourceElement.findall('.groups'):\\n if groupsElement.attrib.get('copy') == '1':\\n self.groupsSource = sourceName\\n\\n # read the info flag\\n for infoElement in sourceElement.findall(\\\".info\\\"):\\n if infoElement.attrib.get('copy') == '1':\\n self.infoSource = sourceName\\n if infoElement.attrib.get('mute') == '1':\\n self.muted['info'].append(sourceName)\\n\\n # read the features flag\\n for featuresElement in sourceElement.findall(\\\".features\\\"):\\n if featuresElement.attrib.get('copy') == '1':\\n if self.featuresSource is not None:\\n self.featuresSource = None\\n else:\\n self.featuresSource = sourceName\\n\\n mutedGlyphs = []\\n for glyphElement in sourceElement.findall(\\\".glyph\\\"):\\n glyphName = glyphElement.attrib.get('name')\\n if glyphName is None:\\n continue\\n if glyphElement.attrib.get('mute') == '1':\\n if not sourceName in self.muted['glyphs']:\\n self.muted['glyphs'][sourceName] = []\\n self.muted['glyphs'][sourceName].append(glyphName)\\n\\n for kerningElement in sourceElement.findall(\\\".kerning\\\"):\\n if kerningElement.attrib.get('mute') == '1':\\n self.muted['kerning'].append(sourceName)\\n\\n # store\\n self.sources[sourceName] = sourceObject, sourceLocationObject\\n self.reportProgress(\\\"prep\\\", 'done')\",\n \"def initialize_observation_files(tile_file_list):\\n n_tiles = len(tile_file_list)\\n if(n_tiles>0):\\n for tile_file in tile_file_list:\\n target_tile_pack = util.TargetTile(tile_file) \\n target_tile_pack.write_results_to_file(tile_file)\\n return\",\n \"def _worker(pipelines: List[Pipeline], source: Queue, sink: Queue):\\n pipelines = list(pipelines)\\n for i, p in enumerate(pipelines):\\n if isinstance(p, ConvertT2S):\\n pipelines[i] = ConvertT2S()\\n\\n def processor(article):\\n for p in pipelines:\\n article = p(article)\\n return article\\n\\n while True:\\n article = source.get()\\n if article == 'EXIT':\\n return\\n article = list(processor(article))\\n sink.put(article)\",\n \"def multiple_eval_for_loops_v1():\",\n \"def run_batch_filter(self):\\n if self.speed_data is None and self.flow_data is None and self.traveltime_data is None:\\n print(\\n 'Warning: The measurement data must be set before running the batch filter: use function self.set_meas_data()')\\n\\n # =======================================================================\\n # the initial ensembles, which should have been set externally\\n X_init = np.matrix(np.zeros((self.dim_state, self.num_ensembles)))\\n print(\\n 'Setting initial ensembles: rho {0}; qin {1}; qout {2}'.format(self.init_rho, self.init_qin, self.init_qout))\\n for ens in range(0, self.num_ensembles):\\n X_init[self.x_index['density'][0]:\\n self.x_index['density'][self.num_cells - 1], ens] = self.init_rho\\n X_init[self.x_index['qin'], ens] = self.init_qin\\n X_init[self.x_index['qout'], ens] = self.init_qout\\n\\n # print('setted qin {0}; qout {1}'.format(X_init[self.x_index['qin'], ens], X_init[self.x_index['qout'], ens] ))\\n # add noise to each ensemble\\n X_init[:, ens] += np.matrix(np.random.multivariate_normal(\\n np.zeros(self.dim_state), self.Q)).reshape((self.dim_state, 1))\\n\\n self.set_initial_ensembles(X_init)\\n\\n # =======================================================================\\n # DEBUG\\n # save the qin and qout in the corresponding probe data\\n # save the initial state\\n if self.__debug:\\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\\n self.qin_obs.append(np.nan)\\n\\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\\n self.qout_obs.append(np.nan)\\n\\n # The enKF runs at the finest time grid\\n # for each step, update the system\\n for step in range(0, self.num_steps):\\n\\n # update status\\n sys.stdout.write('\\\\r')\\n sys.stdout.write('Status: filtering step {0}/{1}'.format(step, self.num_steps))\\n sys.stdout.flush()\\n # print('Status: filtering step {0}'.format(step))\\n\\n cur_time = (step + 1) * self.dur_steps\\n\\n # get the effective measurement\\n eff_flow, eff_speed, eff_traveltime = self.__get_eff_meas(cur_time)\\n\\n # build the observation index\\n self.y_index, self.dim_obs, y_obs, cov_noise = self.__build_obs_index(eff_flow, eff_speed, eff_traveltime)\\n\\n # update the estimate for this step\\n est_state = self.update_estimate(y_obs, cov_noise, cur_time)\\n\\n # =======================================================================\\n # DEBUG\\n # save the qin and qout in the corresponding probe data\\n # save the updated state\\n if self.__debug:\\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\\n if 'flow' in self.y_index.keys() and self.__debug_entrance_sensor in self.y_index['flow'].keys():\\n self.qin_obs.append(y_obs[self.y_index['flow'][self.__debug_entrance_sensor]])\\n # print('y_index[flow]:{0}'.format(self.y_index['flow'].keys()))\\n # print('y_obs[ y_index[flow][entrance] ]:{0}'.format(\\n # y_obs[ self.y_index['flow'][self.__debug_entrance_sensor]],\\n # self.__debug_entrance_sensor))\\n else:\\n self.qin_obs.append(np.nan)\\n\\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\\n if 'flow' in self.y_index.keys() and self.__debug_exit_sensor in self.y_index['flow'].keys():\\n self.qout_obs.append(y_obs[self.y_index['flow'][self.__debug_exit_sensor]])\\n else:\\n self.qout_obs.append(np.nan)\\n # =======================================================================\\n # save the estimated state\\n self.est_state_all[:, step] = est_state\\n\\n # decouple and save into self.est_density, self.est_speed, self.est_queue, self.est_traveltime\\n self.est_density[:, step] = est_state[0:self.num_cells, 0]\\n\\n # the speed is computed using the fundamental diagram\\n for cell_id in range(0, self.num_cells):\\n # use the static FD at this step\\n self.est_speed[cell_id, step] = self.__rho2v(self.vm_cells[cell_id, 0], self.beta_cells[cell_id, 0],\\n self.rhoc_cells[cell_id, 0], self.wc_cells[cell_id, 0],\\n self.est_density[cell_id, step])\\n\\n # REMARK: the queue and travel time a post-processed from the speed field.\\n # They are computed in cross_evaluation class for all algorithms\\n # the queue length starts from the first cell with speed below queue_threshold to the end of road\\n # index = (self.est_speed[:, step] <= self.queue_threshold)\\n #\\n # # filter out the outliers\\n # index_smoothed = deepcopy(index)\\n # outlier_max = 3\\n # counter = 0\\n # for i in range(0, len(index)):\\n #\\n # if index[i] == True:\\n # # trigger the coutner\\n # counter += 1\\n # elif index[i] == False and counter != 0:\\n # if counter <= outlier_max:\\n # # found outliers\\n # index_smoothed[ i-counter : i ] = False\\n # # reset counter\\n # counter = 0\\n #\\n # # if i != 0 and i != len(index)-1:\\n # # if sum( index[i-1:i+3] ) >=2:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n # # elif i == 0:\\n # # if sum(index[0: 5] ) >= 3:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n # # elif i == len(index)-1:\\n # # if sum(index[ i-4 :len(index)]) >= 3:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n #\\n # if sum(index_smoothed) <= 3: # use 4 to suppress false alarms\\n # # if less or equal then 2 cells are in congestion, it may be caused by noise.\\n # self.est_queue[step] = 0\\n # else:\\n # # if step > 105 and step < 115:\\n # # print(sum(index_smoothed))\\n # # print(index_smoothed)\\n # # print(index)\\n #\\n # self.est_queue[step] = \\\\\\n # self.len_cells*( self.num_cells - np.argmax(index_smoothed) )\\n # # try:\\n # # first_cong_cell_id = [x[0] for x in enumerate( self.est_speed[:,step] ) if x[1] < self.queue_threshold][0]\\n # # except IndexError:\\n # # # no congested cell\\n # # first_cong_cell_id = self.num_cells\\n # # # the estimated queue length\\n # # self.est_queue[step] = self.len_cells*( self.num_cells - first_cong_cell_id )\\n #\\n # # the travel time estimate is computed by summing up the travel time in each cell\\n # self.est_traveltime[step] = np.sum(self.len_cells/self.est_speed[:,step])\\n\\n\\n # =======================================================================\\n # DEBUG\\n # plot the update\\n if self.__debug:\\n plot_len = 19\\n # qin\\n if False:\\n if not np.isnan(self.qin_obs[-1]):\\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\\n ax1 = fig1.add_subplot(111)\\n positions_f = np.arange(0, len(self.qin_f)) - 0.1\\n positions_a = np.arange(0, len(self.qin_a)) + 0.1\\n positions_obs = np.arange(0, len(self.qin_obs))\\n # predicted as red\\n bp = ax1.boxplot(self.qin_f[-plot_len:],\\n positions=positions_f[-plot_len:], widths=0.15,\\n patch_artist=False)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#FF4633', linewidth=1)\\n # change fill color\\n # box.set( facecolor = '#FF4633' )\\n # corrected as green\\n bp = ax1.boxplot(self.qin_a[-plot_len:],\\n positions=positions_a[-plot_len:], widths=0.15, patch_artist=False)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#07891B', linewidth=1)\\n # change fill color\\n # box.set( facecolor = '#07891B' )\\n # measurement as blue\\n ax1.scatter(positions_obs[-plot_len:], self.qin_obs[-plot_len:], color='b', marker='o', s=40,\\n label='Observation')\\n ax1.set_title('qin')\\n # x_ticks = np.arange(0, len(self.qin_f))\\n # ax1.set_xticks(x_ticks[-plot_len:])\\n plt.show()\\n\\n # qout\\n if False:\\n if not np.isnan(self.qout_obs[-1]):\\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\\n ax2 = fig2.add_subplot(111)\\n positions_f = np.arange(0, len(self.qout_f)) - 0.1\\n positions_a = np.arange(0, len(self.qout_a)) + 0.1\\n positions_obs = np.arange(0, len(self.qout_obs))\\n # predicted as red\\n bp = ax2.boxplot(self.qout_f[-plot_len:], positions=positions_f[-plot_len:], widths=0.18,\\n patch_artist=True)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#7570b3', linewidth=1)\\n # change fill color\\n box.set(facecolor='#FF4633')\\n # corrected as green\\n bp = ax2.boxplot(self.qout_a[-plot_len:], positions=positions_a[-plot_len:], widths=0.18,\\n patch_artist=True)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#7570b3', linewidth=1)\\n # change fill color\\n box.set(facecolor='#07891B')\\n # measurement as blue\\n ax2.scatter(positions_obs[-plot_len:], self.qout_obs[-plot_len:], color='b', marker='o', s=30,\\n label='Observation')\\n ax2.set_title('qout')\\n # x_ticks = np.arange(0, len(self.qout_f))\\n # ax2.set_xticks(x_ticks[-plot_len:])\\n\\n plt.show()\\n\\n # plot the estimated qin and qout\\n if self.__debug:\\n if True:\\n qin = np.squeeze(np.array(self.est_state_all[self.x_index['qin'], :]))\\n qin_meas = np.array(self.qin_obs)[1:]\\n print(len(qin), len(qin_meas))\\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\\n ax1 = fig1.add_subplot(111)\\n t = np.arange(len(qin))\\n ax1.plot(t, qin, 'r-', label='Estimated')\\n not_nan = ~np.isnan(qin_meas)\\n ax1.plot(t[not_nan], qin_meas[not_nan], 'b', label='Measured')\\n ax1.legend()\\n ax1.grid(True)\\n ax1.set_title('qin')\\n\\n plt.draw()\\n\\n if True:\\n qout = np.squeeze(np.array(self.est_state_all[self.x_index['qout'], :]))\\n qout_meas = np.array(self.qout_obs)[1:]\\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\\n ax2 = fig2.add_subplot(111)\\n t = np.arange(len(qout))\\n ax2.plot(t, qout, 'r-', label='Estimated')\\n not_nan = ~np.isnan(qout_meas)\\n ax2.plot(t[not_nan], qout_meas[not_nan], 'b', label='Measured')\\n ax2.set_title('qout')\\n ax2.legend()\\n ax2.grid(True)\\n plt.draw()\",\n \"def run_all(self):\\n\\n self.run_mash() ###Run MASH analysis\\n self.filter_query() ###Filter fasta sequences out based on p value\\n self.build_index(self.filtered_out_path) ###Build index for off-target analysis\\n os.remove(self.filtered_out_path) ###Clean up intermediate fasta file\\n self.format_gRNA(self.path1) ###Format everything in the right order\\n self.run_OTF() ###Run off-target analysis\\n self.output_parse() ###Parse output values and update table\",\n \"def _collect_all(self):\",\n \"def runScheduler(self):\\n\\n for source in self.sources:\\n intervals = [\\n int(self.sources[source]['metrics'][x]['interval']) for x\\n in range(0, len(self.sources[source]['metrics']))]\\n sourceInterval = self.gcd(intervals)\\n self.sources[source]['sourceInterval'] = sourceInterval\\n self.logger.debug(self.sources[source]['metrics'])\\n\\n self.scheduler.add_job(\\n self.getDriverData, 'interval', args=[\\n self.sources[source]['metrics']],\\n seconds=sourceInterval)\",\n \"def cache_test_sources(self):\\n self.cache_extra_test_sources(self.smoke_test_src)\",\n \"def run(self):\\n self._validate_inputs()\\n if self._destination_out_exists:\\n print('Destination{} already skipping run'.format(self._inputs[-1]))\\n try:\\n if self.operator_func:\\n self.operator_func(*self._inputs)\\n else:\\n raise RuntimeError('self.operator_func is not defined !!')\\n except Exception as ex:\\n print(ex)\\n raise RuntimeError('self.operator_func failed !!')\",\n \"def clsources(ctx):\\n\\t# TODO Use regex instead\\n\\t# this is a poor-man's hack, it relies on the assumption that files\\n\\t# start and end with parenthesis. Put a comment before, and you generate\\n\\t# wrong code. But the source is under my control anyways.\\n\\tfloat_srcfolder = ctx.path.find_node(inc + \\\"/ukoct/opencl/float/sources\\\")\\n\\tcommon_clsources = ctx.path.ant_glob(inc + \\\"/ukoct/opencl/common/**/*.cl\\\")\\n\\tfloat_clsources = [\\n\\t\\tfloat_srcfolder.find_node(\\\"defs.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"coherent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"consistent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"intConsistent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"closed.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"stronglyClosed.inc.cl\\\"),\\n\\t]\\n\\tfloat_clsource = []\\n\\tfor node in common_clsources:\\n\\t\\tsource = node.read()\\n\\t\\tfloat_clsource.append(source[source.find(\\\"(\\\") + 1 : source.rfind(\\\")\\\")])\\n\\tfor node in float_clsources:\\n\\t\\tsource = node.read()\\n\\t\\tfloat_clsource.append(source[source.find(\\\"(\\\") + 1 : source.rfind(\\\")\\\")])\\n\\tctx.path.make_node(\\\"float.cl\\\").write(''.join(float_clsource))\",\n \"def test_parallel_dataflow():\\n\\n if os.path.exists('all.txt'):\\n os.remove('all.txt')\\n\\n # create 5 files with random numbers\\n output_files = []\\n for i in range(5):\\n if os.path.exists('random-%s.txt' % i):\\n os.remove('random-%s.txt' % i)\\n output_files.append(generate(outputs=[File('random-%s.txt' % i)]))\\n\\n # concatenate the files into a single file\\n cc = concat(inputs=[i.outputs[0]\\n for i in output_files], outputs=[File(\\\"all.txt\\\")])\\n\\n # calculate the average of the random numbers\\n totals = total(inputs=[cc.outputs[0]])\\n print(totals.result())\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def do_stage(self, images):\\n\\n for i, image in enumerate(images):\\n pass\\n # logging_tags = logs.image_config_to_tags(image, self.group_by_keywords)\",\n \"def build(self, manager):\\n contents = sorted(self.file_src_dest)\\n output_files_dir = self.output_files_dir\\n all_dest_files = []\\n\\n for src_file, dest_file in contents:\\n all_dest_files += [dest_file]\\n rel = dest_file.relative_to(output_files_dir)\\n yield self.task(\\n name=f\\\"copy:{rel}\\\",\\n doc=f\\\"copy {src_file} to {rel}\\\",\\n file_dep=[src_file],\\n targets=[dest_file],\\n actions=[\\n (self.copy_one, [src_file, dest_file]),\\n ],\\n )\\n\\n if manager.source_date_epoch is not None:\\n yield self.task(\\n name=\\\"timestamp\\\",\\n file_dep=all_dest_files,\\n actions=[\\n (self.maybe_timestamp, [self.output_files_dir]),\\n ],\\n )\",\n \"def train(self) -> None:\\n for module in self.modules.values():\\n module.train()\\n return\",\n \"def setup(self):\\n for gen in self._generators:\\n gen.setup()\",\n \"def test_4():\\n\\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n identity(in_streams[0], out_streams[0])\\n\\n def g(in_streams, out_streams):\\n multiply(in_streams[0], out_streams[0],\\n multiplicand=2)\\n\\n def h(in_streams, out_streams):\\n square(in_streams[0], out_streams[0])\\n\\n def m(in_streams, out_streams):\\n s = Stream('s')\\n sum_numbers(in_streams, s)\\n print_stream(s, name='s')\\n\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n }\\n },\\n 'multiply_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': g,\\n 'sources': {}\\n },\\n 'square_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': h,\\n 'sources': {}\\n },\\n 'merge_process':\\n {'in_stream_names_types': [('in_multiply', 'i'),\\n ('in_square', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': m,\\n 'sources': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('multiply_process', 'in'), ('square_process', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'multiply_process':\\n {\\n 'out' : [('merge_process', 'in_multiply')]\\n },\\n 'square_process':\\n {\\n 'out' : [('merge_process', 'in_square')]\\n },\\n 'merge_process':\\n {\\n }\\n }\\n\\n multicore(processes, connections)\",\n \"def _run(self):\\n self._algorithm(self._list, self)\",\n \"def run_pending_inits(self, session):\\n while self._init_ops:\\n session.run(self._init_ops.pop(0))\",\n \"def _process_datasets_all_frames(self):\\n datasets = os.listdir(self.separated_root)\\n for dataset in datasets:\\n dataset_path = join(self.separated_root, dataset)\\n\\n for model in self.models:\\n\\n attacks_list = os.listdir(dataset_path)\\n\\n for attack in attacks_list:\\n attack_path = join(dataset_path, attack)\\n\\n for prop in self.properties:\\n property_alias = prop.get_property_alias()\\n\\n if os.path.exists(\\n join(self.output_features, dataset, attack, property_alias, model.alias)):\\n print('%s already extracted features' % dataset)\\n continue\\n\\n path_train = join(attack_path, self.train_alias)\\n path_test = join(attack_path, self.test_alias)\\n\\n X_train, y_train, indexes_train, samples_train = self._get_dataset_contents(path_train,\\n property_alias)\\n X_test, y_test, indexes_test, samples_test = self._get_dataset_contents(path_test,\\n property_alias)\\n\\n output_features = join(self.output_features, dataset, attack, property_alias, model.alias)\\n\\n features_train = self._fetch_features(X_train, model, output_features, self.train_alias)\\n features_test = self._fetch_features(X_test, model, output_features, self.test_alias)\\n\\n # saving features\\n np.save(join(output_features, (NAME_FEATURES % self.train_alias)), features_train)\\n np.save(join(output_features, (NAME_FEATURES % self.test_alias)), features_test)\\n\\n # saving targets\\n np.save(join(output_features, (NAME_TARGETS % self.train_alias)), y_train)\\n np.save(join(output_features, (NAME_TARGETS % self.test_alias)), y_test)\\n np.save(join(output_features, (NAME_TARGETS % self.test_alias)), y_test)\\n\\n # saving samples names\\n self.__save_txt(join(output_features, (NAME_SAMPLES % self.train_alias)), samples_train)\\n self.__save_txt(join(output_features, (NAME_SAMPLES % self.test_alias)), samples_test)\",\n \"def clean_up(self):\\n try:\\n data_dir = os.environ[\\\"DATA\\\"]\\n plots_dir = os.environ[\\\"PLOTS\\\"]\\n logs_dir = os.environ[\\\"LOGS\\\"]\\n except KeyError as detail:\\n print \\\"GenerateSpectrum.clean_up: error\\\", detail, \\\"not set\\\"\\n print \\\" --> source analysis environment scripts before running!\\\"\\n sys.exit(1)\\n for root, dirs, files in os.walk(os.getcwd()):\\n for file in files:\\n is_data = re.search(r\\\".*\\\\.root$\\\", file)\\n is_plot = re.search(r\\\".*\\\\.png$\\\", file)\\n hostname = socket.gethostname()\\n is_log = re.search(r\\\"^rat\\\\.\\\"+hostname+r\\\"\\\\.[0-9]+\\\\.log$\\\", file)\\n if is_data:\\n try:\\n root_file = TFile(file)\\n tree = root_file.Get(\\\"T\\\")\\n tree.ls()\\n except ReferenceError as detail:\\n \\\"generate_spectrum.clean_up: error in TFile,\\\", detail\\n sys.exit(1)\\n file_manips.copy_file(os.path.join(root, file), data_dir)\\n elif is_plot:\\n file_manips.copy_file(os.path.join(root, file), plots_dir)\\n elif is_log:\\n file_manips.copy_file(os.path.join(root, file), logs_dir)\",\n \"def run(self, sources, task=\\\"discover\\\", once=False):\\n condition = True\\n while condition:\\n # list of urls\\n self.logger.info(\\\"Reading source urls from '%s'\\\" % sources)\\n self.__read_sources_doc__(sources)\\n # reset url --> destination map. New mappings may be configured\\n DestinationMap.__set_map_filename__(Config().\\n prop(Config.key_location_mapper_destination_file, \\\"conf/desmap.txt\\\"))\\n # drop to force fresh read from file\\n DestinationMap().__drop__()\\n # Set the root of the destination folder if configured\\n DestinationMap().set_root_folder(Config().prop(Config.key_destination_root))\\n # do all the urls\\n self.__do_task__(task)\\n # report\\n self.__do_report__(task)\\n # to continue or not to continue\\n condition = not (once or self.__stop__())\\n if condition:\\n pause = Config().int_prop(Config.key_sync_pause)\\n self.logger.info(\\\"Going to sleep for %d seconds.\\\" % pause)\\n self.logger.debug(\\\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\\")\\n time.sleep(pause)\\n # repeat after sleep\\n condition = not (once or self.__stop__())\",\n \"def run(self, *args, **kwargs):\\n info_list = self._merge()\\n self._run(info_list)\",\n \"def scan(self, sources):\\n\\t\\tself.sources = sources\\n\\t\\tself.start()\",\n \"def scan(self, sources):\\n\\t\\tself.sources = sources\\n\\t\\tself.start()\",\n \"def prepare_gen(self, targets):\\r\\n pass\",\n \"def run_experiments(data_set=\\\"\\\",compact=2,exp_name=\\\"\\\",x=\\\"\\\"):\\n cwd = os.getcwd()\\n results_path = cwd+'/data/geometric/'+exp_name+'_'\\n dataset_path = cwd+'/data/geometric/'+data_set+'_'\\n compact = int(compact)\\n if \\\"m\\\" in x:\\n # make new pxy\\n pxy, Xdata, groups = gen_geometric_pxy()\\n np.save(dataset_path+'Xdata',Xdata)\\n np.save(dataset_path+'groups',groups)\\n np.save(dataset_path+'pxy',pxy)\\n else:\\n # load existing pxy\\n pxy = np.load(dataset_path+'pxy.npy')\\n if \\\"r\\\" in x: # regular experiments\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise.csv')\\n if \\\"ip\\\" in x: # initialization experiments - positive p0\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_pos(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_pos.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_pos(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_pos.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_p0_pos(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_pos.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_pos.csv')\\n if \\\"in\\\" in x: # initialization experiments - negative p0\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_neg(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_neg.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_p0_neg(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_p0_neg.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_p0_neg(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_p0_neg.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_p0_neg.csv')\\n if \\\"c\\\" in x: # convergence tolerance experiments\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_ctol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_ctol.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_ctol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_ctol.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_ctol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_ctol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_ctol.csv')\\n if \\\"z\\\" in x: # zeroL tolerance experiments\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_zeroLtol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_zeroLtol.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_zeroLtol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_zeroLtol.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_zeroLtol(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_zeroLtol.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_zeroLtol.csv')\\n if \\\"b\\\" in x: # trying proposed optimal beta\\n if compact>1:\\n metrics_stepwise, distributions_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps, distributions_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_bestbeta.pkl')\\n elif compact>0:\\n metrics_stepwise,\\\\\\n metrics_converged, distributions_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps, distributions_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\\n distributions_converged.to_pickle(results_path+'distributions_converged_bestbeta.pkl')\\n else:\\n metrics_stepwise,\\\\\\n metrics_converged,\\\\\\n metrics_stepwise_allreps,\\\\\\n metrics_converged_allreps = test_IB(pxy,compact)\\n metrics_converged.to_csv(results_path+'metrics_converged_bestbeta.csv')\\n metrics_stepwise.to_csv(results_path+'metrics_stepwise_bestbeta.csv')\\n return 0\",\n \"def initialize_sources(self, init_srcs=None, init_src_params=None, photoobj_df=None):\\n if init_srcs is not None:\\n self.srcs = init_srcs\\n elif init_src_params is not None:\\n self.srcs = [self._source_type(s, self) for s in init_src_params]\\n elif photoobj_df is not None:\\n self.srcs = [self._source_type(du.photoobj_to_celestepy_src(p), self)\\n for (i, p) in photoobj_df.iterrows()]\\n else:\\n raise NotImplementedError\",\n \"def _insertAllSteps(self): \\n self.uMics = self.inputCoordinatesTiltedPairs.get().getUntilted().getMicrographs()\\n self.tMics = self.inputCoordinatesTiltedPairs.get().getTilted().getMicrographs()\\n\\n self.inputMics = self._createSetOfParticles('auxMics')\\n self.inputMics.copyInfo(self.uMics)\\n self.inputMics.setStore(False)\\n \\n for micU, micT in izip(self.uMics, self.tMics):\\n micU.cleanObjId()\\n micT.cleanObjId()\\n self.inputMics.append(micU)\\n self.inputMics.append(micT)\\n\\n self.samplingInput = self.uMics.getSamplingRate()\\n \\n\\n if self.downsampleType.get() != OTHER:\\n # If 'same as picking' or 'original' get sampling rate from input micrographs\\n #TODO: Review this when downsampling before picking is possible\\n self.samplingFinal = self.samplingInput\\n else:\\n # If 'other' multiply the input sampling rate by the factor provided\\n self.samplingFinal = self.samplingInput*self.downFactor.get()\\n \\n # Write pos files for each micrograph\\n firstStepId = self._insertFunctionStep('writePosFilesStep')\\n \\n # For each micrograph insert the steps\\n #run in parallel\\n \\n deps = []\\n for mic in self.inputMics:\\n localDeps = [firstStepId]\\n micrographToExtract = mic.getFileName()\\n micName = removeBaseExt(mic.getFileName())\\n micId = mic.getObjId()\\n\\n # If downsample type is 'other' perform a downsample\\n if self.downsampleType == OTHER:\\n fnDownsampled = self._getTmpPath(micName+\\\"_downsampled.xmp\\\")\\n downFactor = self.downFactor.get()\\n args = \\\"-i %(micrographToExtract)s -o %(fnDownsampled)s --step %(downFactor)f --method fourier\\\"\\n localDeps=[self._insertRunJobStep(\\\"xmipp_transform_downsample\\\", args % locals(),prerequisites=localDeps)]\\n micrographToExtract = fnDownsampled\\n \\n # If remove dust \\n if self.doRemoveDust:\\n fnNoDust = self._getTmpPath(micName+\\\"_noDust.xmp\\\")\\n \\n thresholdDust = self.thresholdDust.get() #TODO: remove this extra variable\\n args=\\\" -i %(micrographToExtract)s -o %(fnNoDust)s --bad_pixels outliers %(thresholdDust)f\\\"\\n localDeps=[self._insertRunJobStep(\\\"xmipp_transform_filter\\\", args % locals(),prerequisites=localDeps)]\\n micrographToExtract = fnNoDust\\n \\n #self._insertFunctionStep('getCTF', micId, micName, micrographToExtract)\\n micName = removeBaseExt(mic.getFileName())\\n \\n # Actually extract\\n deps.append(self._insertFunctionStep('extractParticlesStep', micId, micName, \\n None, micrographToExtract, prerequisites=localDeps))\\n # TODO: Delete temporary files\\n \\n # Insert step to create output objects \\n self._insertFunctionStep('createOutputStep', prerequisites=deps)\",\n \"def do_pass(self, min_ops, transformer):\\n assert isinstance(min_ops, Iterable), \\\"Ops passed into do_pass must be an iterable\\\"\\n has_work = True\\n while True:\\n if not has_work:\\n return\\n\\n self.replacement_list = []\\n\\n # pass through the ops in an execution order collecting things to do\\n ops = Op.ordered_ops(op.forwarded for op in min_ops)\\n for op in ops:\\n op.update_forwards()\\n self.visit(op)\\n\\n # Perform the gathered replacements\\n for old, rep in self.replacement_list:\\n old.forwarded.replace_self(rep.forwarded)\\n has_work = len(self.replacement_list) > 0\\n min_ops = list(op.forwarded for op in min_ops)\",\n \"def reset(targets):\",\n \"def prepare_outer_loop(initial_sampler: InitialSampler,\\n initial_log_density: Callable[[Array], Array],\\n final_log_density: Callable[[Array], Array],\\n flow_func: Callable[[Array], Tuple[Array, Array]],\\n config) -> AlgoResultsTuple:\\n\\n key = jax.random.PRNGKey(config.seed)\\n\\n flow_forward_fn = hk.without_apply_rng(hk.transform(flow_func))\\n key, subkey = jax.random.split(key)\\n single_normal_sample = initial_sampler(subkey,\\n config.batch_size,\\n config.sample_shape)\\n key, subkey = jax.random.split(key)\\n flow_init_params = flow_forward_fn.init(subkey,\\n single_normal_sample)\\n\\n if config.algo == 'vi':\\n opt = optax.adam(config.optimization_config.vi_step_size)\\n opt_init_state = opt.init(flow_init_params)\\n results = vi.outer_loop_vi(initial_sampler=initial_sampler,\\n opt_update=opt.update,\\n opt_init_state=opt_init_state,\\n flow_init_params=flow_init_params,\\n flow_apply=flow_forward_fn.apply,\\n key=key,\\n initial_log_density=initial_log_density,\\n final_log_density=final_log_density,\\n config=config)\\n elif config.algo == 'smc':\\n results = smc.outer_loop_smc(initial_log_density=initial_log_density,\\n final_log_density=final_log_density,\\n initial_sampler=initial_sampler,\\n key=key,\\n config=config)\\n elif config.algo == 'aft':\\n opt = optax.adam(config.optimization_config.aft_step_size)\\n opt_init_state = opt.init(flow_init_params)\\n # Add a log_step_output function here to enable non-trivial step logging.\\n log_step_output = None\\n results = aft.outer_loop_aft(opt_update=opt.update,\\n opt_init_state=opt_init_state,\\n flow_init_params=flow_init_params,\\n flow_apply=flow_forward_fn.apply,\\n initial_log_density=initial_log_density,\\n final_log_density=final_log_density,\\n initial_sampler=initial_sampler,\\n key=key,\\n config=config,\\n log_step_output=log_step_output)\\n else:\\n raise NotImplementedError\\n return results\",\n \"def multiple_eval_for_loops_v2():\",\n \"def fill_artifacts_at_runtime(self, args):\\n for j in self.jobs:\\n j.fill_artifacts_at_runtime(args)\",\n \"def warmup(self, urls: Sequence[str]):\\n self._log.info(\\\"warming up on %d urls\\\", len(urls))\\n for url in urls:\\n for analyzer in self._analyzers:\\n self._model_repository.get(self._model_id(analyzer), analyzer.model_type, url)\",\n \"def run_stage_loop(cls, _opts, tests_results, put_next_stage):\\n for _, result in tests_results:\\n put_next_stage(result)\",\n \"def update_source_files(source_directory_list, source_extension_list):\\n # get source files in the directory list\\n source_total = 0\\n for unused, source_directory in enumerate(source_directory_list):\\n source_files_list = []\\n get_requested_files(source_directory, source_extension_list, source_files_list)\\n # update the files with shared object references\\n for unused, source_file in enumerate(source_files_list):\\n updated_file = []\\n file_changed = modify_input_file(source_file, updated_file)\\n if file_changed:\\n filepath = get_printble_filepath(source_file)\\n print(filepath)\\n source_total += 1\\n if __file_update:\\n write_output_file(updated_file, source_file)\\n print(\\\"Total Files\\\", source_total)\\n print()\",\n \"def main(self):\\n lines=open(self.expttxt,'r').readlines()\\n if self.parall:\\n pool=Pool(self.prod)\\n pool.map(self.mutatraj,lines)\\n pool.close()\\n pool.join()\\n else:\\n for line in lines:\\n self.mutatraj(line)\",\n \"def _init_targets(self):\\n for ga_main, ga_targ in zip(self.ga.variables, self.ga_.variables):\\n ga_targ.assign(ga_main)\\n if self.use_lyapunov:\\n for lc_main, lc_targ in zip(self.lc.variables, self.lc_.variables):\\n lc_targ.assign(lc_main)\\n else:\\n for q_1_main, q_1_targ in zip(self.q_1.variables, self.q_1_.variables):\\n q_1_targ.assign(q_1_main)\\n for q_2_main, q_2_targ in zip(self.q_2.variables, self.q_2_.variables):\\n q_2_targ.assign(q_2_main)\",\n \"def run_experiment(config) -> AlgoResultsTuple:\\n log_density_initial = getattr(densities, config.initial_config.density)(\\n config.initial_config, config.sample_shape[0])\\n log_density_final = getattr(densities, config.final_config.density)(\\n config.final_config, config.sample_shape[0])\\n initial_sampler = getattr(samplers,\\n config.initial_sampler_config.initial_sampler)(\\n config.initial_sampler_config)\\n\\n def flow_func(x):\\n if is_flow_algorithm(config.algo):\\n flow = getattr(flows, config.flow_config.type)(config.flow_config)\\n return jax.vmap(flow)(x)\\n else:\\n return None\\n\\n results = prepare_outer_loop(initial_sampler, log_density_initial,\\n log_density_final, flow_func, config)\\n return results\",\n \"def execute(self):\\n for _ in self:\\n pass\\n\\n return self\",\n \"def rep(self):\\n origin, pipeline_builder = self._get_origin(self.origin)\\n destination, pipeline_builder = self._get_destination(self.destination, pipeline_builder)\\n pipeline_builder.add_error_stage('Discard')\\n\\n if self.number_of_processors == 4:\\n stream_selector, pipeline_builder = self._get_stream_selector(pipeline_builder)\\n expression_evaluator, pipeline_builder = self._get_expression_evaluator(pipeline_builder)\\n field_type_converter, pipeline_builder = self._get_field_type_converter(pipeline_builder)\\n schema_generator, pipeline_builder = self._get_schema_generator(pipeline_builder)\\n trash, pipeline_builder = self._get_destination('Trash', pipeline_builder)\\n\\n origin >> stream_selector\\n stream_selector >> trash\\n stream_selector >> expression_evaluator >> field_type_converter >> schema_generator >> destination\\n\\n stream_selector.condition = [{'outputLane': stream_selector.output_lanes[0],\\n 'predicate': '${record:attribute(\\\"sourceId\\\") == \\\"DOESNOTEXIST\\\"}'},\\n {'outputLane': stream_selector.output_lanes[1],\\n 'predicate': 'default'}]\\n else:\\n origin >> destination\\n\\n for environment in self.environments.values():\\n if environment is not None:\\n pipeline = pipeline_builder.build().configure_for_environment(environment)\\n\\n results = self.sdc_executor.benchmark_pipeline(pipeline,\\n record_count=self.record_count,\\n runs=self.runs)\\n\\n results['generated_date'] = str(datetime.now())\\n results['sdc_version'] = self.sdc_builder.version\\n results['origin'] = self.origin\\n results['destination'] = self.destination\\n results['record_count'] = self.record_count\\n results['threads'] = self.number_of_threads\\n results['dataset'] = DATASETS[self.dataset]['label']\\n results['batch_size'] = self.batch_size\\n results['destination_data_format'] = self.destination_format\\n results['processor_count'] = self.number_of_processors\\n results['cpu_count'] = len(psutil.Process().cpu_affinity())\\n results['memory_gb'] = round(psutil.virtual_memory().total / (1000 ** 3))\\n try:\\n results['instance_type'] = urlopen('http://169.254.169.254/latest/meta-data/instance-type').read().decode('utf-8')\\n except (HTTPError, URLError):\\n results['instance_type'] = 'unknown'\\n\\n results['origin_system'] = self.origin_system\\n results['destination_system'] = self.destination_system\\n\\n # Remove outliers\\n if len(results['runs']) > 1:\\n results['runs'] = [x for x in results['runs'] if -STD_DEV_THRESHOLD < (x - results['throughput_mean']) / results['throughput_std_dev'] < STD_DEV_THRESHOLD]\\n results['throughput_mean'] = statistics.mean(results['runs'])\\n\\n with open(f\\\"results/{results['pipeline_id']}.json\\\", \\\"w\\\") as file:\\n json.dump(results, file)\\n\\n # Cleanup\\n if self.destination == 'Kafka Producer':\\n admin_client = KafkaAdminClient(bootstrap_servers=self.environments['cluster'].kafka.brokers, request_timeout_ms=180000)\\n admin_client.delete_topics([self.destination_kafka_topic])\\n\\n if self.destination == 'JDBC Producer':\\n self.destination_table.drop(self.environments['database'].engine)\\n\\n if self.origin == 'HTTP Client':\\n self.http_mock.delete_mock()\",\n \"def sources(self, sources):\\n\\n self._sources = sources\",\n \"def reset(self):\\n\\t\\tself.globalQueue = PriorityQueue()\\n\\t\\tself.simTime = 0\\n\\t\\tself.sources = []\\n\\t\\tfor i in range(self.no_of_sources):\\n\\t\\t\\t# s = Source(random.random())#, transfer_rate = 4, packet_size = 100, bandwidth = 1000, switch = None)\\n\\t\\t\\ts = Source(random.random(), transfer_rate = self.source_tranfer_rate[i], packet_size = 100, bandwidth = self.source_bandwith[i], switch = None)\\n\\t\\t\\tself.sources.append(s)\\n\\t\\tself.switch = Switch(output_bandwidth =self.output_bandwidth, source_list = self.sources, queue_size = self.queue_size, sink = None)\\n\\t\\tself.switch.list_sources()\\n\\t\\tself.sink = Sink(switch =self.switch)\\n\\t\\t# connect the sink to the switch\\n\\t\\tself.switch.add_sink(self.sink)\\n\\t\\t# now we need to add the switch to the source\\n\\t\\tfor s in self.sources:\\n\\t\\t\\ts.connect_to_switch(self.switch)\\n\\t\\t## all connections have been done\\n\\t\\t# no packets and push into queue_size\\n\\t\\tinitial_events = []\\n\\t\\tfor s in self.sources:\\n\\t\\t\\te = s.Produce_Event0(self.simTime)\\n\\t\\t\\tinitial_events.append(e)\\n\\t\\t\\tself.globalQueue.put(e)\",\n \"def download_artifacts(self):\\n for artifact_set in self._sets:\\n for artifact in artifact_set.artifacts:\\n artifact.download(self._cache_dir)\",\n \"def InjectSources(self, sources):\\n hydro = integrator.Integrator().hydro\\n # Clear values first\\n self._totalte = 0.0\\n self._totalke = 0.0\\n self._totalmass = 0.0\\n self._totalphotons = 0.0\\n self._sources = sources\\n # Add to the input arrays\\n for source in sources.sources:\\n source.Inject(self)\\n # Dump input values onto the grid\\n if self._totalmass > 0:\\n hydro.mass[0] += self._totalmass\\n if self._totalte > 0:\\n hydro.TE[0] += self._totalte\\n if self._totalke > 0:\\n hydro.KE[0] += self._totalke\\n if self._totalphotons > 0:\\n radiation.trace_radiation(self._totalphotons)\\n self._sources = None\",\n \"def __call__(self, manager=None):\\n # set up a reporter\\n reporter = reporting.Reporter()\\n if self.name is not None:\\n prefix = self.name + '/'\\n else:\\n prefix = ''\\n for name, target in self._targets.items():\\n reporter.add_observer(prefix + name, target)\\n reporter.add_observers(prefix + name,\\n target.named_modules())\\n\\n with reporter:\\n with torch.no_grad():\\n result = self.evaluate()\\n\\n reporting.report(result)\\n return result\",\n \"def initialize_single_source(vs, es, s):\\n for v in vs:\\n v._ss_d = np.inf\\n v._ss_pi = None\\n v._ss_edge = None\\n s._ss_d = 0\",\n \"def run(self):\\n # get components list\\n #component_id_list = self.getComponentsList()\\n asset_id = 3776\\n component_id_list = self.get_component_info_for_one_asset(asset_id)\\n # call computeResults method\\n results = self.compute_results(component_id_list)\\n # write to the output file\\n self.write_to_file(results)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6483219","0.62053764","0.59726936","0.5708577","0.56067014","0.5595243","0.5565407","0.55493075","0.5513938","0.5458577","0.54373556","0.53742665","0.5362166","0.5355955","0.5340015","0.53185433","0.53077227","0.5302345","0.5282659","0.52769977","0.52768093","0.52750057","0.5271185","0.52685887","0.526421","0.5243496","0.5225009","0.5210927","0.52086383","0.52043617","0.5196092","0.517297","0.5155293","0.5147476","0.514734","0.5146911","0.51421064","0.51371056","0.5136704","0.51337045","0.5122432","0.51214606","0.5110907","0.5107747","0.51031667","0.5102889","0.5101561","0.5097526","0.50894123","0.50601053","0.5057106","0.505582","0.504513","0.5041716","0.50414646","0.5032773","0.5030881","0.5024705","0.50119054","0.5008323","0.50048006","0.5003142","0.49969873","0.4988288","0.49880117","0.4986416","0.49842185","0.4979984","0.49798113","0.49796858","0.49782768","0.49738255","0.49731752","0.4969766","0.49665195","0.49665195","0.49664423","0.4964168","0.49597952","0.4958758","0.4955779","0.49531186","0.4947625","0.494581","0.49442163","0.4941335","0.49396276","0.49389955","0.4938453","0.49381322","0.49257007","0.491788","0.49151814","0.49136996","0.49110934","0.49099997","0.49075416","0.49071035","0.4904905","0.490298"],"string":"[\n \"0.6483219\",\n \"0.62053764\",\n \"0.59726936\",\n \"0.5708577\",\n \"0.56067014\",\n \"0.5595243\",\n \"0.5565407\",\n \"0.55493075\",\n \"0.5513938\",\n \"0.5458577\",\n \"0.54373556\",\n \"0.53742665\",\n \"0.5362166\",\n \"0.5355955\",\n \"0.5340015\",\n \"0.53185433\",\n \"0.53077227\",\n \"0.5302345\",\n \"0.5282659\",\n \"0.52769977\",\n \"0.52768093\",\n \"0.52750057\",\n \"0.5271185\",\n \"0.52685887\",\n \"0.526421\",\n \"0.5243496\",\n \"0.5225009\",\n \"0.5210927\",\n \"0.52086383\",\n \"0.52043617\",\n \"0.5196092\",\n \"0.517297\",\n \"0.5155293\",\n \"0.5147476\",\n \"0.514734\",\n \"0.5146911\",\n \"0.51421064\",\n \"0.51371056\",\n \"0.5136704\",\n \"0.51337045\",\n \"0.5122432\",\n \"0.51214606\",\n \"0.5110907\",\n \"0.5107747\",\n \"0.51031667\",\n \"0.5102889\",\n \"0.5101561\",\n \"0.5097526\",\n \"0.50894123\",\n \"0.50601053\",\n \"0.5057106\",\n \"0.505582\",\n \"0.504513\",\n \"0.5041716\",\n \"0.50414646\",\n \"0.5032773\",\n \"0.5030881\",\n \"0.5024705\",\n \"0.50119054\",\n \"0.5008323\",\n \"0.50048006\",\n \"0.5003142\",\n \"0.49969873\",\n \"0.4988288\",\n \"0.49880117\",\n \"0.4986416\",\n \"0.49842185\",\n \"0.4979984\",\n \"0.49798113\",\n \"0.49796858\",\n \"0.49782768\",\n \"0.49738255\",\n \"0.49731752\",\n \"0.4969766\",\n \"0.49665195\",\n \"0.49665195\",\n \"0.49664423\",\n \"0.4964168\",\n \"0.49597952\",\n \"0.4958758\",\n \"0.4955779\",\n \"0.49531186\",\n \"0.4947625\",\n \"0.494581\",\n \"0.49442163\",\n \"0.4941335\",\n \"0.49396276\",\n \"0.49389955\",\n \"0.4938453\",\n \"0.49381322\",\n \"0.49257007\",\n \"0.491788\",\n \"0.49151814\",\n \"0.49136996\",\n \"0.49110934\",\n \"0.49099997\",\n \"0.49075416\",\n \"0.49071035\",\n \"0.4904905\",\n \"0.490298\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77062124"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90998,"cells":{"query":{"kind":"string","value":"Run forever, sleeping for the configured interval between each run."},"document":{"kind":"string","value":"def run_forever(self):\n while True:\n self.run_once()\n\n self.logger.info(f\"Sleeping for {self.config.sleep()} seconds\")\n time.sleep(self.config.sleep())"},"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 loop_forever(self):\n while self.running:\n time.sleep(0.01)","def loop_forever(self):\n self.running = True\n while self.running:\n time.sleep(0.1)","def run(self, forever=False, interval=300):\n\n bot_start_time = time.time()\n\n while True:\n try:\n self.process_posts()\n except Exception as e:\n logging.exception(\"bot:run\")\n rollbar.report_exc_info()\n\n if not forever:\n break\n\n sleep_interval = float(interval) - ((time.time() - bot_start_time) % float(interval))\n\n logging.info(\"Sleeping for {0} seconds until next run.\".format(sleep_interval))\n time.sleep(sleep_interval)","def run(self):\n while True:\n print(\"I'm running in the background\")\n time.sleep(self.interval)","def sleep(interval):\n time.sleep(interval) # pragma: no cover","def run_forever(self):\n self._loop.run_until_complete(self._loop_body())","def wait_forever(self):\r\n while True:\r\n time.sleep(0.5)","def run_continuously(self, interval: int = 1):\n cease_continuous_run = threading.Event()\n\n class ScheduleThread(threading.Thread):\n @classmethod\n def run(cls):\n while not cease_continuous_run.is_set():\n schedule.run_pending()\n time.sleep(interval)\n\n continuous_thread = ScheduleThread()\n continuous_thread.start()\n return cease_continuous_run","def loop_forever(self):\n self.client.loop_forever()","def run(self):\n while True:\n # Do something\n print('Doing something imporant in the background')\n\n self.loadData()\n time.sleep(self.interval)","def run_forever(self):\n self.ws.run_forever()","def loop(self):\n while True:\n delay_until_next = self.tick()\n if not delay_until_next:\n break\n self._sleep(delay_until_next)","def run(self):\n last_time = time.time()\n while self.running:\n now_time = time.time()\n interval = now_time - last_time\n last_time = now_time\n self.update(interval)\n time.sleep(Options['update interval'])","def run(self):\n rate = rospy.Rate(self._run_rate)\n while not rospy.is_shutdown():\n try:\n rate.sleep()\n except:\n break","def run_forever(func):\n def forever_wrapped():\n waittime = 1.\n lastwait = time.time()\n while True:\n try:\n func()\n except KeyboardInterrupt: # we allow user to interrupt us ;-\n print(\"User abort\")\n return\n except IOError as ioe:\n print(\"Connection was closed: %s\" % str(ioe))\n except IncompleteRead as ire:\n print(\"Twitter sending us shit: %s\" % str(ire))\n except RuntimeError as re:\n print(\"Problem during this run: %s\" % str(re))\n except BaseException as e:\n traceback.print_exception(type(e), e, sys.exc_info()[2])\n else:\n print(\"Terminated... \", end=\"\")\n\n now = time.time()\n # reset waittime when we ran for at least 10 minute without issues\n if lastwait + waittime + 600 < now:\n waittime = 1.\n lastwait = now\n\n print(\"Restarting in %.0f seconds\" % waittime)\n signal.alarm(0) # reset watchdog here :-/\n time.sleep(waittime)\n\n # max wait time is 20min\n waittime = min(20 * 60, waittime * 2) # exponential backoff\n return forever_wrapped","def run(self):\n r = rospy.Rate(100)\n while not rospy.is_shutdown():\n r.sleep()","def run_forever(self):\n self.factory.manager.run_forever()","def run_forever(self):\n asyncio.run(self._loop_body())","async def test_interval_none_repeat(self):\n await self.populate_test_data() # Populate data in foglamp.scheduled_processes\n\n scheduler = Scheduler(_address, _m_port)\n await scheduler.start()\n\n # assert that the schedule type is interval\n interval_schedule = IntervalSchedule()\n assert interval_schedule.schedule_type == Schedule.Type.INTERVAL\n\n interval_schedule.name = 'sleep10'\n interval_schedule.process_name = \"sleep10\"\n interval_schedule.repeat = datetime.timedelta(seconds=0)\n\n await scheduler.save_schedule(interval_schedule)\n\n await asyncio.sleep(1)\n # Assert only 1 task is running\n tasks = await scheduler.get_running_tasks()\n assert len(tasks) == 1\n\n await asyncio.sleep(12)\n # Assert only 1 task is running\n tasks = await scheduler.get_running_tasks()\n assert len(tasks) == 1\n\n await self.stop_scheduler(scheduler)","def sleep(self):\n # Just spending cycles of sleep till next date\n timeTarget = self.startTime + timedelta(hours=int(self.newsFrequency))\n while datetime.now() < timeTarget:\n # sleep for 30 min\n # TODO move time to sleep into config\n logging.info(f\"Sleep for 30 min target to wakeup {timeTarget}\")\n time.sleep(60*30)","def run(self):\n time_to_quit = False\n while True:\n time_to_quit = self.run_to_yield_or_quit()\n if time_to_quit:\n print(self, 'quitting')\n break\n else:\n time.sleep(self.polling_interval)","def sleep_for_cloudinit():\n run(\"sleep 15\")","def run(self):\n if self.config.daemon():\n self.logger.info(\"Running forever, in a loop\")\n self.run_forever()\n else:\n self.logger.info(\"Running once, to completion\")\n self.run_once()","def background_catch_up():\n while True:\n time.sleep(interval)\n s = 'http://{0}:{1}'.format(args.host, port)\n req = urllib2.Request(s)\n try:\n response = urllib2.urlopen(req)\n response.read()\n except Exception as e:\n pass","def run(self):\n try:\n while self._running:\n time.sleep(1)\n finally:\n self._exit()","def run(self):\n while True:\n try:\n sleep(influx_settings.write_freq)\n self._redis2influx()\n except InterruptExceptions as ex:\n raise ex","def loop_forever(self):\n while True:\n if self.get_parameter_value(\"publishing_mode\") == \"continuous\":\n self.publishMeasure()","async def _ping_loop(self, interval: float):\n while True:\n await asyncio.sleep(interval)\n self._send(\n PacketHeader(\n client_id=u32(self._cid), flags=PacketFlags.PING\n ).serialize()\n )","def run(self):\n while True:\n self.current_wifi_clients()\n self._eval_is_someone_home()\n time.sleep(self._interval)","def run(self):\n while True:\n self.sm.run()\n time.sleep(0.05)","def run(seconds=1):\n time.sleep(seconds)\n print('Slept for ',seconds,' seconds')","def AutonomousPeriodic(self):\n Scheduler.GetInstance().Run()","def run(self):\n if not self.running:\n self.loop.run_forever()","def Schedule(interval=3600):\n # TODO:: if func need to return something\n def schedule(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n while True:\n start_time = time.perf_counter()\n func(*args, **kwargs)\n running_time = time.perf_counter()-start_time\n latency = interval-running_time\n logger.debug(\n f'Next program:{func.__name__} will start at {latency} sec later.')\n time.sleep(latency)\n return wrapper(*args, **kwargs)\n return wrapper\n return schedule","async def async_run_forever(self):\n raise NotImplementedError","def run(self):\n #=======================================================================\n #\n # TODO: Replace this do-nothing code with some which does something.\n # Don't worry about looping (though you can), since this will be called\n # over and over again by the main appliance loop.\n #\n #=======================================================================\n self.logger.info('Nothing to do; sleeping for a while.')\n sleep(10)\n\n # Return something truthy to continue, anything else to exit.\n return True","def schedule_every(time_interval: float, to_repeat: 'function to call repeatedly'):\n # TODO - use module sched ?\n # https://stackoverflow.com/questions/474528/what-is-the-best-way-to-repeatedly-execute-a-function-every-x-seconds-in-python\n\n time.sleep(time_interval)\n while True:\n start_time = time.time()\n end_time = time.time()\n to_repeat()\n processing_time = end_time - start_time\n print(processing_time)\n time.sleep(time_interval - processing_time)\n\n # TODO - find a way to avoid the drift better? Like we could take into account the date in the logs","def wake_till(seconds):\n while True:\n if int(time.time()) < seconds:\n time.sleep(5)\n else:\n return","def wait(interval):\n time.sleep(interval/1000.0)","def sleep(self):\n self.sleep_after(1) # Can't be 0, that means 'don't sleep'","def run(self):\n\n self.halt = False\n\n print(\"Starting heartbeat.\")\n while not self.halt:\n event = events.TickEvent()\n AppState.get_state().get_event_manager().post_event(event)\n AppState.get_state().get_clock().tick(settings.MAX_FPS)","def run(self):\n # starting program, run hello feeds\n self.do_jobs(self.run_start)\n\n while not self.terminate:\n now = time.localtime()\n now_time = now.tm_hour * 60 + now.tm_min\n\n # next run is at most 30sec away\n next_run = 30\n\n # button hold triggered\n if self.button_hold:\n self.button_hold = False\n self.do_jobs(self.run_hold)\n\n # button tap triggered\n if self.button_tap:\n self.button_tap = False\n self.do_jobs(self.run_tap)\n\n # look for scheduled feeds to run\n when_tasks = []\n for t in self.run_when:\n if t['when'] <= now_time:\n if not t['ran_today']:\n t['ran_today'] = True\n when_tasks.append(t)\n else:\n t['ran_today'] = False\n self.do_jobs(when_tasks)\n\n # look for interval feeds to run\n interval_tasks = []\n for t in self.run_interval:\n if t['next'] <= time.mktime(now):\n t['next'] = time.mktime(now) + t['interval']\n interval_tasks.append(t)\n if time.mktime(now) - t['next'] < next_run:\n next_run = time.mktime(now) - t['next']\n\n self.do_jobs(interval_tasks)\n\n # wait until we have work to do\n if next_run >= 1:\n signal.alarm(next_run)\n signal.pause()\n else:\n time.sleep(0.25)\n\n # quitting program, run stop feeds\n self.do_jobs(self.run_stop)","def run(every=45):\n print(f\"Scheduling refuel time for every {every} minutes.\")\n seconds = every * 60\n pic = Path.joinpath(Path(__file__).parent, \"pic.png\")\n try:\n img = Image.open(pic)\n while(True):\n for i in tqdm.trange(seconds):\n time.sleep(1)\n print(f\"Taking rest at {time.ctime()}\")\n img.show()\n except:\n print(\"Have a good day!\")\n img.close()","def run(self):\n while self.running:\n self.__update_battery()\n self.__update_signal()\n time.sleep(5)","def loop(self):\n while not self.should_exit:\n self._run_once()\n\n self.on_exit()","async def restless_sleep(duration):\n\n while duration > 0:\n await asyncio.sleep(1)\n\n # Poll for program running state\n if Program.is_running():\n duration = duration - 1\n continue\n\n # Otherwise, program is done running, raise an exception to be caught\n raise ProgramShutdownError","def delay(interval):\n time.sleep(interval / 1000.0)","def _loop(self):\n while True:\n if GameLoop.getInstance()._cancelation_token==True:\n break\n self._update_signal.notify_all()\n sleep(1/60)","async def _async_repeat(self, func):\n while True:\n start = time.monotonic()\n await func()\n timeout = (self.period/1000.) - (time.monotonic()-start)\n if timeout > 0:\n await asyncio.sleep(timeout)","def run_forever(self):\n while True:\n self.listener.ready()\n yield self.listener.wait()\n self.listener.ok()","def Listen(self):\n while True:\n time.sleep(1)","def sleep(self):\n current_time = time.time()\n\n if not self.next_time: # first call\n self.next_time = current_time + self.period\n return\n\n delta = self.next_time - current_time\n if delta > 0:\n time.sleep(delta)\n self.next_time += self.period","def _wait_forever(self, sleep = 60):\r\n\r\n # marks the current (parent) process as running and sets\r\n # its current state as \"started\"\r\n self._running = True\r\n self._pausing = False\r\n self.set_state(STATE_START)\r\n\r\n # iterates continuously (infinite loop) until the running\r\n # flag is unmarked indicating that the loop should be stopped\r\n try:\r\n while self._running:\r\n try:\r\n self._awaken = True\r\n try: self._delays()\r\n finally: self._awaken = False\r\n time.sleep(sleep)\r\n except errors.WakeupError:\r\n continue\r\n except (KeyboardInterrupt, SystemExit, errors.StopError, errors.PauseError):\r\n raise\r\n except BaseException as exception:\r\n self.error(exception)\r\n self.log_stack(method = self.warning)\r\n finally:\r\n if hasattr(self, \"_awaken\"): del self._awaken","def run(self):\n while self.time <= self.deadline:\n self.setup_period()\n self.execute_process(self.select_process())\n\n self.time += 1","def main_loop():\n while len(fake_threads) > 0:\n pulse(0.1)","def sleep_for(timeToSleep):\r\n time.sleep(timeToSleep)","def run_forever(self, accounts_count: int):\n\n print( Fore.BLUE + ':: Watching Session Files ... ::' )\n self.reload_sessions()\n\n print( Fore.BLUE + ':: Reloading Accuonts Info ... ::' )\n self.reload_info()\n\n self.start(accounts_count)\n\n print( Fore.YELLOW + ':: Started Handlers (Running forever) ::' )\n self.block()","def sleep(seconds: typing.Union[float, int]):\n if seconds == 0:\n yield\n elif seconds == inf:\n yield from sleepinf()\n else:\n end = monotonic() + seconds\n while end >= monotonic():\n yield","def start_daemon(interval=600):\n thread = threading.Thread(target=daemon_job, args=(interval, ))\n thread.daemon = True\n thread.start()","def repeat_every(seconds, fn):\n def wrapper(scheduler):\n try:\n fn()\n scheduler.enter(seconds, 1, wrapper, (scheduler,))\n except:\n print('Error executing function')\n\n scheduler = sched.scheduler(time.time, time.sleep)\n scheduler.enter(seconds, 1, wrapper, (scheduler,))\n scheduler.run()","def run(self):\n while self._running:\n temp = self._sense.get_temperature()\n self.display_temperature(temp)\n sleep(10)\n self._sense.clear()","def sleep(self, seconds=60):\n\t\ttime.sleep(seconds)","def daemon_job(interval):\n time.sleep(3) # Wait for api server to start first\n while True:\n try:\n crawl()\n process_notification()\n except Exception:\n traceback.print_exc()\n time.sleep(interval)","async def periodic_refresh(self):\n started_cycle = time()\n while True:\n now = time()\n if (now - started_cycle) < CYCLE_DELAY:\n await asyncio.sleep(CYCLE_DELAY - (now - started_cycle) + 1)\n started_cycle = time()\n await self.refresh_cache()\n # Never exits.","def run_forever(self):\n self.starting()\n self.keep_running = True\n\n def handle(signum, frame):\n self.interrupt()\n self.keep_running = False\n\n signal.signal(signal.SIGINT, handle)\n\n while self.keep_running:\n if self.max_tasks and self.tasks_complete >= self.max_tasks:\n self.stopping()\n\n if self.gator.len():\n result = self.gator.pop()\n self.tasks_complete += 1\n self.result(result)\n\n if self.nap_time >= 0:\n time.sleep(self.nap_time)\n\n return 0","def sleep(seconds):\n time.sleep(seconds)","def sleep(seconds):\n time.sleep(seconds)","def _sleep(self):\n while 1:\n diff = (time.time()-self.lastcall) - self.mindelay\n if diff >= 0: return\n time.sleep(max(-diff/2.0, 0.01))","def run(self):\n\n self._daemon_thread.start()\n\n while True:\n time.sleep(5)","def sleep(seconds):\r\n time.sleep(seconds)","def work(self):\n time.sleep(random.randint(0, 200) / 100)\n pass","def pulse(seconds):\n index = 0\n while index < len(fake_threads):\n t = fake_threads[index]\n t['sleep'] -= seconds\n if t['sleep'] <= 0:\n t['sleep'] = 0\n t['next_sleep_time'] = None\n t['greenlet'].run()\n sleep_time = t['next_sleep_time']\n if sleep_time is None or isinstance(sleep_time, tuple):\n del fake_threads[index]\n index -= 1\n else:\n t['sleep'] = sleep_time\n index += 1","def _event_loop(self):\n while True:\n self.scheduler.run(blocking=True)\n time.sleep(1)","def run(self):\n while True:\n self.logger.info(\"Scraping...\")\n print('scraping...')\n decks = []\n try:\n decks.extend(scrape_decks())\n except Exception as e:\n print('scraping exception' + str(e))\n self.logger.exception(\n 'Scraper for TappedOut raised an exception'\n )\n\n self.insert_decks(decks)\n\n self.logger.info(\n \"Done scraping, sleeping for {} days\".format(self.interval)\n )\n time.sleep(self.interval * (60 * 60 * 24))","def forever(shard):\n def repeat(*args, **kwargs):\n while True:\n for delay in shard(*args, **kwargs):\n yield delay\n return repeat","def run_checks():\n while True:\n if datetime.now() > core.misc_data.check_date+timedelta(minutes=45):\n for stuff in stuff_to_do:\n threading.Thread(target=stuff).start()\n core.misc_data.check_date = datetime.now() + config.utils.tasks.repeat_every\n time.sleep(5*60*60)","def run(self):\n\t\twhile True:\n\t\t\tself.clock.tick(self.settings.max_fps)\n\t\t\tself._check_events()\n\t\t\tself._update_screen()","def block_while_running():\n runs = is_running()\n while runs:\n runs = is_running()\n time.sleep(10)","def trigger_daily(self, wait, start, interval):\n if start < time.time():\n cycle = int((time.time() - start) / interval) + 1\n start = cycle * interval + start\n\n if not wait:\n return start\n\n fine_delay = self.time_frame / 10\n time.sleep(start - time.time() - fine_delay)\n return fine_delay","def _update_schedule(self, interval):\n while True:\n if Schedule().update_current_week():\n self._view_schedule()\n print 'Yes'\n time.sleep(interval)","def __sleep(self):\n if self.sleep_duration > 0:\n gevent.sleep(self.sleep_duration)\n else:\n self.__warn(\n f\"The average tick took longer than the set tick duration of {self.__tick_duration}. \"\n f\"Program is to heavy to run real time\")","def run(self):\n while not self.terminate_event.is_set():\n while self.count > 0 and self.start_event.is_set() and self.interval > 0:\n if self.tick_log:\n if (self.count * self.sleep_chunk - int(self.count * self.sleep_chunk)) == 0.0:\n self.log.debug(\"{name} countdown: {tick} ({interval}s @ step {step:.2f}s)\"\n .format(name=self.name, tick=self.count,\n interval=self.interval, step=self.sleep_chunk))\n if self.reset_event.wait(self.sleep_chunk):\n self.reset_event.clear()\n self.count = self.interval / self.sleep_chunk\n self.count -= 1\n if self.count <= 0:\n self._callback()\n self.count = self.interval / self.sleep_chunk","async def _run(self) -> None:\n while True:\n try:\n await self._func()\n except asyncio.CancelledError:\n raise\n except Exception:\n logging.exception('Executing periodic task.')\n await asyncio.sleep(self._ival)","def sleep(sleep_time=0.250):\n time.sleep(sleep_time)","def infinite_loop():\n return True","def sleep(seconds):\n # After load and initializing the PvAPI Python's built-in 'sleep' function\n # stops working (returns too early). The is a replacement.\n from time import sleep,time\n t = t0 = time()\n while t < t0+seconds: sleep(t0+seconds - t); t = time()","def snooze(self, interval: Optional[float] = 300.0):\n self._get_backend().snooze_alarm(interval=interval)","async def every(\n interval: float, initial_delay: float = 0\n) -> AsyncGenerator[float, Optional[float]]:\n start_time = trio.current_time()\n undelayed_yield_times = (\n start_time + interval * iteration for iteration in itertools.count()\n )\n delay = initial_delay\n\n for undelayed_yield_time in undelayed_yield_times:\n yield_time = undelayed_yield_time + delay\n await trio.sleep_until(yield_time)\n\n additional_delay = yield yield_time\n if additional_delay is not None:\n delay += additional_delay","def run(self): \n next_period = self._interval\n next_time = time()\n\n while not self.stopped.wait(next_period):\n try:\n self._execute(*self._args, **self._kwargs)\n except Exception as e:\n logging.exception(type(e).__name__ + \" is raise from \" + str(self._execute))\n if self._exception != False and isinstance(e, self._exception):\n break\n next_time += self._interval\n next_period = next_time - time()","async def _main(self):\n while True:\n time.sleep(1)","def start(self, pattern):\n if self.loopForever:\n while self.loopForever and self.run:\n self.do_run(pattern)\n return\n for x in range(self.loop):\n if self.run:\n self.do_run(pattern)\n else:\n return","def run(self):\n self.logger.info(f'Running {self.__class__.__name__}')\n while True:\n last_check = time.time()\n self.collect_new_events()\n while time.time() - last_check < self._check_for_new_events_interval:\n self.logger.debug('Waiting for new events collection: new collection in {}s'.format(\n self._check_for_new_events_interval - (time.time() - last_check)))\n time.sleep(1)","def run_forever(self):\n self.app.run()","def run(self): # pragma: no cover\n while True:\n self.update()","def schedule_periodically(self, _interval, _callback, *_args, **_kwargs):\n if isinstance(_interval, datetime.timedelta):\n _interval = _interval.total_seconds()\n\n @coroutine\n @functools.wraps(_callback)\n def inner():\n while True:\n yield from asyncio.sleep(_when)\n ret = _callback(*_args, **_kwargs)\n if ret is False:\n break\n\n return self.schedule_async(inner())","def run(self, run_forever=False):\n logger.info(\"Running socket factory (%s)\", self.poller.__class__.__name__)\n self.create_pending_sockets()\n if run_forever:\n cond = lambda: True\n else:\n if self.write_delay:\n cond = lambda: bool(self.sockets)\n else:\n cond = lambda: len(self.sockets) > 1\n # Wait for any socket\n while not cond():\n time.sleep(1)\n last_tick = last_stale = time.time()\n while cond() and not self.to_shutdown:\n self.loop(1)\n t = time.time()\n if self.tick_callback and t - last_tick >= 1:\n self.metrics.ticks += 1\n try:\n self.tick_callback()\n except Exception:\n error_report()\n logger.info(\"Restoring from tick() failure\")\n last_tick = t\n if t - last_stale >= 1:\n self.close_stale()\n last_stale = t\n logger.info(\"Stopping socket factory\")","def run_forever(self):\n return self.gw.run()","def __run_schedules():\n while True:\n __scheduler.run()","def periodic_timer(self):\n while self.running:\n self.sendStatusQuery()\n time.sleep(REPORT_INTERVAL)","def sleep(self):\n self._epd.sleep()"],"string":"[\n \"def loop_forever(self):\\n while self.running:\\n time.sleep(0.01)\",\n \"def loop_forever(self):\\n self.running = True\\n while self.running:\\n time.sleep(0.1)\",\n \"def run(self, forever=False, interval=300):\\n\\n bot_start_time = time.time()\\n\\n while True:\\n try:\\n self.process_posts()\\n except Exception as e:\\n logging.exception(\\\"bot:run\\\")\\n rollbar.report_exc_info()\\n\\n if not forever:\\n break\\n\\n sleep_interval = float(interval) - ((time.time() - bot_start_time) % float(interval))\\n\\n logging.info(\\\"Sleeping for {0} seconds until next run.\\\".format(sleep_interval))\\n time.sleep(sleep_interval)\",\n \"def run(self):\\n while True:\\n print(\\\"I'm running in the background\\\")\\n time.sleep(self.interval)\",\n \"def sleep(interval):\\n time.sleep(interval) # pragma: no cover\",\n \"def run_forever(self):\\n self._loop.run_until_complete(self._loop_body())\",\n \"def wait_forever(self):\\r\\n while True:\\r\\n time.sleep(0.5)\",\n \"def run_continuously(self, interval: int = 1):\\n cease_continuous_run = threading.Event()\\n\\n class ScheduleThread(threading.Thread):\\n @classmethod\\n def run(cls):\\n while not cease_continuous_run.is_set():\\n schedule.run_pending()\\n time.sleep(interval)\\n\\n continuous_thread = ScheduleThread()\\n continuous_thread.start()\\n return cease_continuous_run\",\n \"def loop_forever(self):\\n self.client.loop_forever()\",\n \"def run(self):\\n while True:\\n # Do something\\n print('Doing something imporant in the background')\\n\\n self.loadData()\\n time.sleep(self.interval)\",\n \"def run_forever(self):\\n self.ws.run_forever()\",\n \"def loop(self):\\n while True:\\n delay_until_next = self.tick()\\n if not delay_until_next:\\n break\\n self._sleep(delay_until_next)\",\n \"def run(self):\\n last_time = time.time()\\n while self.running:\\n now_time = time.time()\\n interval = now_time - last_time\\n last_time = now_time\\n self.update(interval)\\n time.sleep(Options['update interval'])\",\n \"def run(self):\\n rate = rospy.Rate(self._run_rate)\\n while not rospy.is_shutdown():\\n try:\\n rate.sleep()\\n except:\\n break\",\n \"def run_forever(func):\\n def forever_wrapped():\\n waittime = 1.\\n lastwait = time.time()\\n while True:\\n try:\\n func()\\n except KeyboardInterrupt: # we allow user to interrupt us ;-\\n print(\\\"User abort\\\")\\n return\\n except IOError as ioe:\\n print(\\\"Connection was closed: %s\\\" % str(ioe))\\n except IncompleteRead as ire:\\n print(\\\"Twitter sending us shit: %s\\\" % str(ire))\\n except RuntimeError as re:\\n print(\\\"Problem during this run: %s\\\" % str(re))\\n except BaseException as e:\\n traceback.print_exception(type(e), e, sys.exc_info()[2])\\n else:\\n print(\\\"Terminated... \\\", end=\\\"\\\")\\n\\n now = time.time()\\n # reset waittime when we ran for at least 10 minute without issues\\n if lastwait + waittime + 600 < now:\\n waittime = 1.\\n lastwait = now\\n\\n print(\\\"Restarting in %.0f seconds\\\" % waittime)\\n signal.alarm(0) # reset watchdog here :-/\\n time.sleep(waittime)\\n\\n # max wait time is 20min\\n waittime = min(20 * 60, waittime * 2) # exponential backoff\\n return forever_wrapped\",\n \"def run(self):\\n r = rospy.Rate(100)\\n while not rospy.is_shutdown():\\n r.sleep()\",\n \"def run_forever(self):\\n self.factory.manager.run_forever()\",\n \"def run_forever(self):\\n asyncio.run(self._loop_body())\",\n \"async def test_interval_none_repeat(self):\\n await self.populate_test_data() # Populate data in foglamp.scheduled_processes\\n\\n scheduler = Scheduler(_address, _m_port)\\n await scheduler.start()\\n\\n # assert that the schedule type is interval\\n interval_schedule = IntervalSchedule()\\n assert interval_schedule.schedule_type == Schedule.Type.INTERVAL\\n\\n interval_schedule.name = 'sleep10'\\n interval_schedule.process_name = \\\"sleep10\\\"\\n interval_schedule.repeat = datetime.timedelta(seconds=0)\\n\\n await scheduler.save_schedule(interval_schedule)\\n\\n await asyncio.sleep(1)\\n # Assert only 1 task is running\\n tasks = await scheduler.get_running_tasks()\\n assert len(tasks) == 1\\n\\n await asyncio.sleep(12)\\n # Assert only 1 task is running\\n tasks = await scheduler.get_running_tasks()\\n assert len(tasks) == 1\\n\\n await self.stop_scheduler(scheduler)\",\n \"def sleep(self):\\n # Just spending cycles of sleep till next date\\n timeTarget = self.startTime + timedelta(hours=int(self.newsFrequency))\\n while datetime.now() < timeTarget:\\n # sleep for 30 min\\n # TODO move time to sleep into config\\n logging.info(f\\\"Sleep for 30 min target to wakeup {timeTarget}\\\")\\n time.sleep(60*30)\",\n \"def run(self):\\n time_to_quit = False\\n while True:\\n time_to_quit = self.run_to_yield_or_quit()\\n if time_to_quit:\\n print(self, 'quitting')\\n break\\n else:\\n time.sleep(self.polling_interval)\",\n \"def sleep_for_cloudinit():\\n run(\\\"sleep 15\\\")\",\n \"def run(self):\\n if self.config.daemon():\\n self.logger.info(\\\"Running forever, in a loop\\\")\\n self.run_forever()\\n else:\\n self.logger.info(\\\"Running once, to completion\\\")\\n self.run_once()\",\n \"def background_catch_up():\\n while True:\\n time.sleep(interval)\\n s = 'http://{0}:{1}'.format(args.host, port)\\n req = urllib2.Request(s)\\n try:\\n response = urllib2.urlopen(req)\\n response.read()\\n except Exception as e:\\n pass\",\n \"def run(self):\\n try:\\n while self._running:\\n time.sleep(1)\\n finally:\\n self._exit()\",\n \"def run(self):\\n while True:\\n try:\\n sleep(influx_settings.write_freq)\\n self._redis2influx()\\n except InterruptExceptions as ex:\\n raise ex\",\n \"def loop_forever(self):\\n while True:\\n if self.get_parameter_value(\\\"publishing_mode\\\") == \\\"continuous\\\":\\n self.publishMeasure()\",\n \"async def _ping_loop(self, interval: float):\\n while True:\\n await asyncio.sleep(interval)\\n self._send(\\n PacketHeader(\\n client_id=u32(self._cid), flags=PacketFlags.PING\\n ).serialize()\\n )\",\n \"def run(self):\\n while True:\\n self.current_wifi_clients()\\n self._eval_is_someone_home()\\n time.sleep(self._interval)\",\n \"def run(self):\\n while True:\\n self.sm.run()\\n time.sleep(0.05)\",\n \"def run(seconds=1):\\n time.sleep(seconds)\\n print('Slept for ',seconds,' seconds')\",\n \"def AutonomousPeriodic(self):\\n Scheduler.GetInstance().Run()\",\n \"def run(self):\\n if not self.running:\\n self.loop.run_forever()\",\n \"def Schedule(interval=3600):\\n # TODO:: if func need to return something\\n def schedule(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n while True:\\n start_time = time.perf_counter()\\n func(*args, **kwargs)\\n running_time = time.perf_counter()-start_time\\n latency = interval-running_time\\n logger.debug(\\n f'Next program:{func.__name__} will start at {latency} sec later.')\\n time.sleep(latency)\\n return wrapper(*args, **kwargs)\\n return wrapper\\n return schedule\",\n \"async def async_run_forever(self):\\n raise NotImplementedError\",\n \"def run(self):\\n #=======================================================================\\n #\\n # TODO: Replace this do-nothing code with some which does something.\\n # Don't worry about looping (though you can), since this will be called\\n # over and over again by the main appliance loop.\\n #\\n #=======================================================================\\n self.logger.info('Nothing to do; sleeping for a while.')\\n sleep(10)\\n\\n # Return something truthy to continue, anything else to exit.\\n return True\",\n \"def schedule_every(time_interval: float, to_repeat: 'function to call repeatedly'):\\n # TODO - use module sched ?\\n # https://stackoverflow.com/questions/474528/what-is-the-best-way-to-repeatedly-execute-a-function-every-x-seconds-in-python\\n\\n time.sleep(time_interval)\\n while True:\\n start_time = time.time()\\n end_time = time.time()\\n to_repeat()\\n processing_time = end_time - start_time\\n print(processing_time)\\n time.sleep(time_interval - processing_time)\\n\\n # TODO - find a way to avoid the drift better? Like we could take into account the date in the logs\",\n \"def wake_till(seconds):\\n while True:\\n if int(time.time()) < seconds:\\n time.sleep(5)\\n else:\\n return\",\n \"def wait(interval):\\n time.sleep(interval/1000.0)\",\n \"def sleep(self):\\n self.sleep_after(1) # Can't be 0, that means 'don't sleep'\",\n \"def run(self):\\n\\n self.halt = False\\n\\n print(\\\"Starting heartbeat.\\\")\\n while not self.halt:\\n event = events.TickEvent()\\n AppState.get_state().get_event_manager().post_event(event)\\n AppState.get_state().get_clock().tick(settings.MAX_FPS)\",\n \"def run(self):\\n # starting program, run hello feeds\\n self.do_jobs(self.run_start)\\n\\n while not self.terminate:\\n now = time.localtime()\\n now_time = now.tm_hour * 60 + now.tm_min\\n\\n # next run is at most 30sec away\\n next_run = 30\\n\\n # button hold triggered\\n if self.button_hold:\\n self.button_hold = False\\n self.do_jobs(self.run_hold)\\n\\n # button tap triggered\\n if self.button_tap:\\n self.button_tap = False\\n self.do_jobs(self.run_tap)\\n\\n # look for scheduled feeds to run\\n when_tasks = []\\n for t in self.run_when:\\n if t['when'] <= now_time:\\n if not t['ran_today']:\\n t['ran_today'] = True\\n when_tasks.append(t)\\n else:\\n t['ran_today'] = False\\n self.do_jobs(when_tasks)\\n\\n # look for interval feeds to run\\n interval_tasks = []\\n for t in self.run_interval:\\n if t['next'] <= time.mktime(now):\\n t['next'] = time.mktime(now) + t['interval']\\n interval_tasks.append(t)\\n if time.mktime(now) - t['next'] < next_run:\\n next_run = time.mktime(now) - t['next']\\n\\n self.do_jobs(interval_tasks)\\n\\n # wait until we have work to do\\n if next_run >= 1:\\n signal.alarm(next_run)\\n signal.pause()\\n else:\\n time.sleep(0.25)\\n\\n # quitting program, run stop feeds\\n self.do_jobs(self.run_stop)\",\n \"def run(every=45):\\n print(f\\\"Scheduling refuel time for every {every} minutes.\\\")\\n seconds = every * 60\\n pic = Path.joinpath(Path(__file__).parent, \\\"pic.png\\\")\\n try:\\n img = Image.open(pic)\\n while(True):\\n for i in tqdm.trange(seconds):\\n time.sleep(1)\\n print(f\\\"Taking rest at {time.ctime()}\\\")\\n img.show()\\n except:\\n print(\\\"Have a good day!\\\")\\n img.close()\",\n \"def run(self):\\n while self.running:\\n self.__update_battery()\\n self.__update_signal()\\n time.sleep(5)\",\n \"def loop(self):\\n while not self.should_exit:\\n self._run_once()\\n\\n self.on_exit()\",\n \"async def restless_sleep(duration):\\n\\n while duration > 0:\\n await asyncio.sleep(1)\\n\\n # Poll for program running state\\n if Program.is_running():\\n duration = duration - 1\\n continue\\n\\n # Otherwise, program is done running, raise an exception to be caught\\n raise ProgramShutdownError\",\n \"def delay(interval):\\n time.sleep(interval / 1000.0)\",\n \"def _loop(self):\\n while True:\\n if GameLoop.getInstance()._cancelation_token==True:\\n break\\n self._update_signal.notify_all()\\n sleep(1/60)\",\n \"async def _async_repeat(self, func):\\n while True:\\n start = time.monotonic()\\n await func()\\n timeout = (self.period/1000.) - (time.monotonic()-start)\\n if timeout > 0:\\n await asyncio.sleep(timeout)\",\n \"def run_forever(self):\\n while True:\\n self.listener.ready()\\n yield self.listener.wait()\\n self.listener.ok()\",\n \"def Listen(self):\\n while True:\\n time.sleep(1)\",\n \"def sleep(self):\\n current_time = time.time()\\n\\n if not self.next_time: # first call\\n self.next_time = current_time + self.period\\n return\\n\\n delta = self.next_time - current_time\\n if delta > 0:\\n time.sleep(delta)\\n self.next_time += self.period\",\n \"def _wait_forever(self, sleep = 60):\\r\\n\\r\\n # marks the current (parent) process as running and sets\\r\\n # its current state as \\\"started\\\"\\r\\n self._running = True\\r\\n self._pausing = False\\r\\n self.set_state(STATE_START)\\r\\n\\r\\n # iterates continuously (infinite loop) until the running\\r\\n # flag is unmarked indicating that the loop should be stopped\\r\\n try:\\r\\n while self._running:\\r\\n try:\\r\\n self._awaken = True\\r\\n try: self._delays()\\r\\n finally: self._awaken = False\\r\\n time.sleep(sleep)\\r\\n except errors.WakeupError:\\r\\n continue\\r\\n except (KeyboardInterrupt, SystemExit, errors.StopError, errors.PauseError):\\r\\n raise\\r\\n except BaseException as exception:\\r\\n self.error(exception)\\r\\n self.log_stack(method = self.warning)\\r\\n finally:\\r\\n if hasattr(self, \\\"_awaken\\\"): del self._awaken\",\n \"def run(self):\\n while self.time <= self.deadline:\\n self.setup_period()\\n self.execute_process(self.select_process())\\n\\n self.time += 1\",\n \"def main_loop():\\n while len(fake_threads) > 0:\\n pulse(0.1)\",\n \"def sleep_for(timeToSleep):\\r\\n time.sleep(timeToSleep)\",\n \"def run_forever(self, accounts_count: int):\\n\\n print( Fore.BLUE + ':: Watching Session Files ... ::' )\\n self.reload_sessions()\\n\\n print( Fore.BLUE + ':: Reloading Accuonts Info ... ::' )\\n self.reload_info()\\n\\n self.start(accounts_count)\\n\\n print( Fore.YELLOW + ':: Started Handlers (Running forever) ::' )\\n self.block()\",\n \"def sleep(seconds: typing.Union[float, int]):\\n if seconds == 0:\\n yield\\n elif seconds == inf:\\n yield from sleepinf()\\n else:\\n end = monotonic() + seconds\\n while end >= monotonic():\\n yield\",\n \"def start_daemon(interval=600):\\n thread = threading.Thread(target=daemon_job, args=(interval, ))\\n thread.daemon = True\\n thread.start()\",\n \"def repeat_every(seconds, fn):\\n def wrapper(scheduler):\\n try:\\n fn()\\n scheduler.enter(seconds, 1, wrapper, (scheduler,))\\n except:\\n print('Error executing function')\\n\\n scheduler = sched.scheduler(time.time, time.sleep)\\n scheduler.enter(seconds, 1, wrapper, (scheduler,))\\n scheduler.run()\",\n \"def run(self):\\n while self._running:\\n temp = self._sense.get_temperature()\\n self.display_temperature(temp)\\n sleep(10)\\n self._sense.clear()\",\n \"def sleep(self, seconds=60):\\n\\t\\ttime.sleep(seconds)\",\n \"def daemon_job(interval):\\n time.sleep(3) # Wait for api server to start first\\n while True:\\n try:\\n crawl()\\n process_notification()\\n except Exception:\\n traceback.print_exc()\\n time.sleep(interval)\",\n \"async def periodic_refresh(self):\\n started_cycle = time()\\n while True:\\n now = time()\\n if (now - started_cycle) < CYCLE_DELAY:\\n await asyncio.sleep(CYCLE_DELAY - (now - started_cycle) + 1)\\n started_cycle = time()\\n await self.refresh_cache()\\n # Never exits.\",\n \"def run_forever(self):\\n self.starting()\\n self.keep_running = True\\n\\n def handle(signum, frame):\\n self.interrupt()\\n self.keep_running = False\\n\\n signal.signal(signal.SIGINT, handle)\\n\\n while self.keep_running:\\n if self.max_tasks and self.tasks_complete >= self.max_tasks:\\n self.stopping()\\n\\n if self.gator.len():\\n result = self.gator.pop()\\n self.tasks_complete += 1\\n self.result(result)\\n\\n if self.nap_time >= 0:\\n time.sleep(self.nap_time)\\n\\n return 0\",\n \"def sleep(seconds):\\n time.sleep(seconds)\",\n \"def sleep(seconds):\\n time.sleep(seconds)\",\n \"def _sleep(self):\\n while 1:\\n diff = (time.time()-self.lastcall) - self.mindelay\\n if diff >= 0: return\\n time.sleep(max(-diff/2.0, 0.01))\",\n \"def run(self):\\n\\n self._daemon_thread.start()\\n\\n while True:\\n time.sleep(5)\",\n \"def sleep(seconds):\\r\\n time.sleep(seconds)\",\n \"def work(self):\\n time.sleep(random.randint(0, 200) / 100)\\n pass\",\n \"def pulse(seconds):\\n index = 0\\n while index < len(fake_threads):\\n t = fake_threads[index]\\n t['sleep'] -= seconds\\n if t['sleep'] <= 0:\\n t['sleep'] = 0\\n t['next_sleep_time'] = None\\n t['greenlet'].run()\\n sleep_time = t['next_sleep_time']\\n if sleep_time is None or isinstance(sleep_time, tuple):\\n del fake_threads[index]\\n index -= 1\\n else:\\n t['sleep'] = sleep_time\\n index += 1\",\n \"def _event_loop(self):\\n while True:\\n self.scheduler.run(blocking=True)\\n time.sleep(1)\",\n \"def run(self):\\n while True:\\n self.logger.info(\\\"Scraping...\\\")\\n print('scraping...')\\n decks = []\\n try:\\n decks.extend(scrape_decks())\\n except Exception as e:\\n print('scraping exception' + str(e))\\n self.logger.exception(\\n 'Scraper for TappedOut raised an exception'\\n )\\n\\n self.insert_decks(decks)\\n\\n self.logger.info(\\n \\\"Done scraping, sleeping for {} days\\\".format(self.interval)\\n )\\n time.sleep(self.interval * (60 * 60 * 24))\",\n \"def forever(shard):\\n def repeat(*args, **kwargs):\\n while True:\\n for delay in shard(*args, **kwargs):\\n yield delay\\n return repeat\",\n \"def run_checks():\\n while True:\\n if datetime.now() > core.misc_data.check_date+timedelta(minutes=45):\\n for stuff in stuff_to_do:\\n threading.Thread(target=stuff).start()\\n core.misc_data.check_date = datetime.now() + config.utils.tasks.repeat_every\\n time.sleep(5*60*60)\",\n \"def run(self):\\n\\t\\twhile True:\\n\\t\\t\\tself.clock.tick(self.settings.max_fps)\\n\\t\\t\\tself._check_events()\\n\\t\\t\\tself._update_screen()\",\n \"def block_while_running():\\n runs = is_running()\\n while runs:\\n runs = is_running()\\n time.sleep(10)\",\n \"def trigger_daily(self, wait, start, interval):\\n if start < time.time():\\n cycle = int((time.time() - start) / interval) + 1\\n start = cycle * interval + start\\n\\n if not wait:\\n return start\\n\\n fine_delay = self.time_frame / 10\\n time.sleep(start - time.time() - fine_delay)\\n return fine_delay\",\n \"def _update_schedule(self, interval):\\n while True:\\n if Schedule().update_current_week():\\n self._view_schedule()\\n print 'Yes'\\n time.sleep(interval)\",\n \"def __sleep(self):\\n if self.sleep_duration > 0:\\n gevent.sleep(self.sleep_duration)\\n else:\\n self.__warn(\\n f\\\"The average tick took longer than the set tick duration of {self.__tick_duration}. \\\"\\n f\\\"Program is to heavy to run real time\\\")\",\n \"def run(self):\\n while not self.terminate_event.is_set():\\n while self.count > 0 and self.start_event.is_set() and self.interval > 0:\\n if self.tick_log:\\n if (self.count * self.sleep_chunk - int(self.count * self.sleep_chunk)) == 0.0:\\n self.log.debug(\\\"{name} countdown: {tick} ({interval}s @ step {step:.2f}s)\\\"\\n .format(name=self.name, tick=self.count,\\n interval=self.interval, step=self.sleep_chunk))\\n if self.reset_event.wait(self.sleep_chunk):\\n self.reset_event.clear()\\n self.count = self.interval / self.sleep_chunk\\n self.count -= 1\\n if self.count <= 0:\\n self._callback()\\n self.count = self.interval / self.sleep_chunk\",\n \"async def _run(self) -> None:\\n while True:\\n try:\\n await self._func()\\n except asyncio.CancelledError:\\n raise\\n except Exception:\\n logging.exception('Executing periodic task.')\\n await asyncio.sleep(self._ival)\",\n \"def sleep(sleep_time=0.250):\\n time.sleep(sleep_time)\",\n \"def infinite_loop():\\n return True\",\n \"def sleep(seconds):\\n # After load and initializing the PvAPI Python's built-in 'sleep' function\\n # stops working (returns too early). The is a replacement.\\n from time import sleep,time\\n t = t0 = time()\\n while t < t0+seconds: sleep(t0+seconds - t); t = time()\",\n \"def snooze(self, interval: Optional[float] = 300.0):\\n self._get_backend().snooze_alarm(interval=interval)\",\n \"async def every(\\n interval: float, initial_delay: float = 0\\n) -> AsyncGenerator[float, Optional[float]]:\\n start_time = trio.current_time()\\n undelayed_yield_times = (\\n start_time + interval * iteration for iteration in itertools.count()\\n )\\n delay = initial_delay\\n\\n for undelayed_yield_time in undelayed_yield_times:\\n yield_time = undelayed_yield_time + delay\\n await trio.sleep_until(yield_time)\\n\\n additional_delay = yield yield_time\\n if additional_delay is not None:\\n delay += additional_delay\",\n \"def run(self): \\n next_period = self._interval\\n next_time = time()\\n\\n while not self.stopped.wait(next_period):\\n try:\\n self._execute(*self._args, **self._kwargs)\\n except Exception as e:\\n logging.exception(type(e).__name__ + \\\" is raise from \\\" + str(self._execute))\\n if self._exception != False and isinstance(e, self._exception):\\n break\\n next_time += self._interval\\n next_period = next_time - time()\",\n \"async def _main(self):\\n while True:\\n time.sleep(1)\",\n \"def start(self, pattern):\\n if self.loopForever:\\n while self.loopForever and self.run:\\n self.do_run(pattern)\\n return\\n for x in range(self.loop):\\n if self.run:\\n self.do_run(pattern)\\n else:\\n return\",\n \"def run(self):\\n self.logger.info(f'Running {self.__class__.__name__}')\\n while True:\\n last_check = time.time()\\n self.collect_new_events()\\n while time.time() - last_check < self._check_for_new_events_interval:\\n self.logger.debug('Waiting for new events collection: new collection in {}s'.format(\\n self._check_for_new_events_interval - (time.time() - last_check)))\\n time.sleep(1)\",\n \"def run_forever(self):\\n self.app.run()\",\n \"def run(self): # pragma: no cover\\n while True:\\n self.update()\",\n \"def schedule_periodically(self, _interval, _callback, *_args, **_kwargs):\\n if isinstance(_interval, datetime.timedelta):\\n _interval = _interval.total_seconds()\\n\\n @coroutine\\n @functools.wraps(_callback)\\n def inner():\\n while True:\\n yield from asyncio.sleep(_when)\\n ret = _callback(*_args, **_kwargs)\\n if ret is False:\\n break\\n\\n return self.schedule_async(inner())\",\n \"def run(self, run_forever=False):\\n logger.info(\\\"Running socket factory (%s)\\\", self.poller.__class__.__name__)\\n self.create_pending_sockets()\\n if run_forever:\\n cond = lambda: True\\n else:\\n if self.write_delay:\\n cond = lambda: bool(self.sockets)\\n else:\\n cond = lambda: len(self.sockets) > 1\\n # Wait for any socket\\n while not cond():\\n time.sleep(1)\\n last_tick = last_stale = time.time()\\n while cond() and not self.to_shutdown:\\n self.loop(1)\\n t = time.time()\\n if self.tick_callback and t - last_tick >= 1:\\n self.metrics.ticks += 1\\n try:\\n self.tick_callback()\\n except Exception:\\n error_report()\\n logger.info(\\\"Restoring from tick() failure\\\")\\n last_tick = t\\n if t - last_stale >= 1:\\n self.close_stale()\\n last_stale = t\\n logger.info(\\\"Stopping socket factory\\\")\",\n \"def run_forever(self):\\n return self.gw.run()\",\n \"def __run_schedules():\\n while True:\\n __scheduler.run()\",\n \"def periodic_timer(self):\\n while self.running:\\n self.sendStatusQuery()\\n time.sleep(REPORT_INTERVAL)\",\n \"def sleep(self):\\n self._epd.sleep()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79261065","0.769201","0.72684103","0.71911734","0.7044903","0.70315796","0.70266116","0.69642824","0.6942898","0.68407226","0.6816066","0.6797461","0.6692905","0.6683687","0.6659617","0.6603098","0.65500087","0.64913917","0.64811295","0.6433807","0.6433627","0.6431587","0.64166075","0.6371954","0.6364926","0.63539684","0.632543","0.63148534","0.63077176","0.6275277","0.62630326","0.62496537","0.6210466","0.6200346","0.619998","0.6177078","0.6145834","0.614003","0.61252475","0.6113162","0.6111925","0.60880697","0.6084664","0.60744005","0.6069286","0.6068984","0.6064482","0.6063189","0.60449183","0.6044816","0.60325766","0.60078734","0.60052514","0.5994161","0.59907645","0.5986519","0.59795326","0.59775317","0.5967768","0.59569234","0.5952762","0.59494525","0.594749","0.5946388","0.5946262","0.59449947","0.59449947","0.59441143","0.5942834","0.5939068","0.59221363","0.5915565","0.5904396","0.5901723","0.588079","0.5876824","0.5872704","0.5870379","0.5862417","0.5837406","0.5817651","0.5817085","0.5815448","0.5812996","0.5807757","0.57959735","0.57927233","0.5789556","0.57884216","0.5777557","0.5775402","0.57705843","0.576906","0.5768161","0.57639575","0.57595646","0.5747269","0.57416344","0.57354766","0.57350606"],"string":"[\n \"0.79261065\",\n \"0.769201\",\n \"0.72684103\",\n \"0.71911734\",\n \"0.7044903\",\n \"0.70315796\",\n \"0.70266116\",\n \"0.69642824\",\n \"0.6942898\",\n \"0.68407226\",\n \"0.6816066\",\n \"0.6797461\",\n \"0.6692905\",\n \"0.6683687\",\n \"0.6659617\",\n \"0.6603098\",\n \"0.65500087\",\n \"0.64913917\",\n \"0.64811295\",\n \"0.6433807\",\n \"0.6433627\",\n \"0.6431587\",\n \"0.64166075\",\n \"0.6371954\",\n \"0.6364926\",\n \"0.63539684\",\n \"0.632543\",\n \"0.63148534\",\n \"0.63077176\",\n \"0.6275277\",\n \"0.62630326\",\n \"0.62496537\",\n \"0.6210466\",\n \"0.6200346\",\n \"0.619998\",\n \"0.6177078\",\n \"0.6145834\",\n \"0.614003\",\n \"0.61252475\",\n \"0.6113162\",\n \"0.6111925\",\n \"0.60880697\",\n \"0.6084664\",\n \"0.60744005\",\n \"0.6069286\",\n \"0.6068984\",\n \"0.6064482\",\n \"0.6063189\",\n \"0.60449183\",\n \"0.6044816\",\n \"0.60325766\",\n \"0.60078734\",\n \"0.60052514\",\n \"0.5994161\",\n \"0.59907645\",\n \"0.5986519\",\n \"0.59795326\",\n \"0.59775317\",\n \"0.5967768\",\n \"0.59569234\",\n \"0.5952762\",\n \"0.59494525\",\n \"0.594749\",\n \"0.5946388\",\n \"0.5946262\",\n \"0.59449947\",\n \"0.59449947\",\n \"0.59441143\",\n \"0.5942834\",\n \"0.5939068\",\n \"0.59221363\",\n \"0.5915565\",\n \"0.5904396\",\n \"0.5901723\",\n \"0.588079\",\n \"0.5876824\",\n \"0.5872704\",\n \"0.5870379\",\n \"0.5862417\",\n \"0.5837406\",\n \"0.5817651\",\n \"0.5817085\",\n \"0.5815448\",\n \"0.5812996\",\n \"0.5807757\",\n \"0.57959735\",\n \"0.57927233\",\n \"0.5789556\",\n \"0.57884216\",\n \"0.5777557\",\n \"0.5775402\",\n \"0.57705843\",\n \"0.576906\",\n \"0.5768161\",\n \"0.57639575\",\n \"0.57595646\",\n \"0.5747269\",\n \"0.57416344\",\n \"0.57354766\",\n \"0.57350606\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83757216"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90999,"cells":{"query":{"kind":"string","value":"Return a dictionary with counts of each artifact type."},"document":{"kind":"string","value":"def artifact_types(artifact_list):\n types = {}\n for artifact in artifact_list:\n artifact_type = artifact.__class__.__name__.lower()\n if artifact_type in types:\n types[artifact_type] += 1\n else:\n types[artifact_type] = 1\n\n return types"},"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 count_freq(self, types=1):\n count_dict = {}\n if types == 1:\n for cat in self.categories:\n num_images = sum(\n [1 for i in self.data['annotations'] if i['category_id'] == self.cats_idx[cat]])\n count_dict[cat] = num_images\n elif types == 2:\n pass\n\n return count_dict","def count_types_by_provider(cls):\n counts = db.Dataset.aggregate([{'$group':{'_id':{'asset_type':'$services.asset_type',\n 'data_provider':'$services.data_provider'},\n 'cnt':{'$sum':1}}}])\n\n # transform into slightly friendlier structure. could likely do this in mongo but no point\n retval = defaultdict(dict)\n for val in counts:\n try:\n retval[val['_id']['data_provider'][0]][val['_id']['asset_type'][0]] = val['cnt']\n except:\n pass\n\n return dict(retval)","def type_count():\n types = []\n for typ in Statistics.all_type():\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\n fix_types = []\n for i in sorted(types, key=lambda k: k['y']):\n if i['y'] != 0:\n fix_types.append(i)\n return jsonify(result=fix_types)","def count_artifact_number(self, context, type_name=None):\n session = api.get_session()\n return api.count_artifact_number(context, session, type_name)","def clothing_type_count(clothes_list):\n types_count = {}\n for garment in clothes_list:\n if garment.db.clothing_type:\n type = garment.db.clothing_type\n if type not in types_count.keys():\n types_count[type] = 1\n else:\n types_count[type] += 1\n return types_count","def count_types():\n classes = {\"Amenity\": Amenity, \"City\": City,\n \"Place\": Place, \"Review\": Review, \"State\": State, \"User\": User}\n my_dict = {}\n for key in classes.keys():\n if (classes[key] == Amenity):\n my_dict[\"amenities\"] = storage.count(classes[key])\n elif (classes[key] == City):\n my_dict[\"cities\"] = storage.count(classes[key])\n elif (classes[key] == Place):\n my_dict[\"places\"] = storage.count(classes[key])\n elif (classes[key] == Review):\n my_dict[\"reviews\"] = storage.count(classes[key])\n elif (classes[key] == State):\n my_dict[\"states\"] = storage.count(classes[key])\n elif (classes[key] == User):\n my_dict[\"users\"] = storage.count(classes[key])\n return (jsonify(my_dict))","def active_type_counts(self):\n names = self.visible()\n return {\n 'total': names.count(),\n 'personal': len([n for n in names if n.is_personal()]),\n 'organization': len([n for n in names if n.is_organization()]),\n 'event': len([n for n in names if n.is_event()]),\n 'software': len([n for n in names if n.is_software()]),\n 'building': len([n for n in names if n.is_building()])\n }","def summarize(self) -> Mapping[str, int]:\n return dict(\n compounds=self.count_compounds(),\n side_effects=self.count_side_effects(),\n indications=self.count_indications(),\n umls=self.count_umls(),\n )","def _get_as_dict_count(self):\n counter = Counter()\n for product in self.products:\n counter[product.id] += 1\n return counter","def artifact_types_get_req():\n return {'status': 'success',\n 'message': '',\n 'types': Artifact.types()}","def get_package_type_counts(dataset_name):\n token = get_access_token()\n\n dataset_id = get_dataset_id(token, dataset_name)\n\n r = requests.get(f\"https://api.pennsieve.io/datasets/{dataset_id}/packageTypeCounts\", headers=create_request_headers(token))\n r.raise_for_status()\n\n return r.json()","def stats():\n class_counts = {}\n convert_dict = {\n 'Amenity': 'amenities',\n 'State': 'states',\n 'City': 'cities',\n 'User': 'users',\n 'Place': 'places',\n 'Review': 'reviews'\n }\n\n for _class in convert_dict.keys():\n class_counts[convert_dict[_class]] = storage.count(_class)\n\n return jsonify(class_counts)","def get_total_counts(self):\n ret = {}\n all_loggers_count = 0\n for logger, name_map in self.acc_map.items():\n cur_logger_count = 0\n ret[logger.name] = {}\n for name, status_map in name_map.items():\n cur_name_count = 0\n ret[logger.name][name] = {}\n for status, acc in status_map.items():\n cur_count = acc.total_count\n ret[logger.name][name][status] = cur_count\n cur_name_count += cur_count\n cur_logger_count += cur_count\n all_loggers_count += cur_count\n ret[logger.name][name]['__all__'] = cur_name_count\n ret[logger.name]['__all__'] = cur_logger_count\n ret['__all__'] = all_loggers_count\n return ret","def view_counts():\n out = {}\n for i in range(len(classes)):\n out.update({decoded[i]: storage.count(classes[i])})\n return out","def get_resource_count(har_json):\n entries = har_json['log']['entries']\n\n resource_type_counts = Counter()\n\n for entry in entries:\n resource = entry['request']['url']\n dirty_resource_type = resource.split('.')[-1]\n resource_type = dirty_resource_type.split('?')[0] # Remove url params\n if len(resource_type) > 4:\n resource_type_counts['other'] += 1\n # print 'Found other resource type: {0}'.format(resource_type)\n else:\n resource_type_counts[resource_type] += 1\n\n return resource_type_counts","def count_items(fileinfos, type, name=\"\"):\n names = [] \n if is_filename(name):\n # count all elements/attributes for one text\n for nodeName in fileinfos[name][\"usage_\" + type].keys():\n names.append(nodeName) \n elif name == \"\":\n # count all elements/attributes for all texts\n for filename in fileinfos:\n for nodeName in fileinfos[filename][\"usage_\" + type].keys():\n names.append(nodeName)\n \n items_counted = {}\n \n if is_filename(name) or name == \"\":\n for singleName in unique_names(names):\n counter = 0\n for file in fileinfos:\n counter += fileinfos[file][\"usage_\" + type].get(singleName, 0)\n items_counted[singleName] = counter\n elif is_attname(name):\n # count attribute usage for all texts\n for file in fileinfos:\n if name[1:] in fileinfos[file][\"usage_att\"].keys():\n items_counted[file] = fileinfos[file][\"usage_att\"][name[1:]]\n else:\n # count element usage for all texts\n for file in fileinfos:\n if name in fileinfos[file][\"usage_el\"].keys():\n items_counted[file] = fileinfos[file][\"usage_el\"][name]\n return items_counted","def get_all_dataset_counts(\n self,\n ) -> Dict[Tuple[str, int, int], int]:\n res = self._engine.execute(\n select(\n [\n PRODUCT.c.name,\n TIME_OVERVIEW.c.start_day,\n TIME_OVERVIEW.c.period_type,\n TIME_OVERVIEW.c.dataset_count,\n ]\n )\n .select_from(TIME_OVERVIEW.join(PRODUCT))\n .where(TIME_OVERVIEW.c.product_ref == PRODUCT.c.id)\n .order_by(\n PRODUCT.c.name, TIME_OVERVIEW.c.start_day, TIME_OVERVIEW.c.period_type\n )\n )\n\n return {\n (\n r.name,\n *TimePeriodOverview.from_flat_period_representation(\n r.period_type, r.start_day\n )[:2],\n ): r.dataset_count\n for r in res\n }","def get_types_count():\n return len(type_dict.keys())","def get_ntype_counts_map(ntypes, ntype_counts):\n return dict(zip(ntypes, ntype_counts))","def DatumTypeCount(self, logfilePath=\"/home/zhenyuan/CTI/ta1-trace-1-e5-official-1.bin.1.json\"):\n with open(logfilePath) as logfile:\n jsonlogs = logfile.readline()\n\n datumTypeSet = set()\n datumTypeCount = dict()\n while jsonlogs:\n logs = json.loads(jsonlogs)\n datumType = list(logs['datum'].keys())[0]\n\n if datumType not in datumTypeSet:\n print(logs)\n datumTypeCount[datumType] = 0\n\n datumTypeSet.add(datumType)\n datumTypeCount[datumType] += 1\n\n jsonlogs = logfile.readline()\n\n return datumTypeSet\n pass","def number_objects():\n classes = [Amenity, City, Place, Review, State, User]\n names = [\"amenities\", \"cities\", \"places\", \"reviews\", \"states\", \"users\"]\n\n num_objs = {}\n for i in range(len(classes)):\n num_objs[names[i]] = storage.count(classes[i])\n\n return jsonify(num_objs)","def apply(self):\n counter = {}\n for act in self.activities:\n freq = []\n for trace in self.log:\n freq.append(len(self.project_trace(trace, [act])))\n if not len(freq) == 0:\n counter[act] = {'sum': sum(freq), 'min': min(freq),\n 'max': max(freq)}\n return counter","def get_attribute_counts(self):\n counts = defaultdict(int)\n for attr in self:\n counts[attr.name] += 1\n\n return dict(counts)","def stats_data_by_type():\n photos = db_session.query(MediaFiles.size).filter(MediaFiles.duration == 0)\n videos = db_session.query(MediaFiles.size).filter(MediaFiles.duration > 0)\n result = [{'name': 'Photos', 'color': '#76BCEB',\n 'data': [photos.with_entities(func.sum(MediaFiles.size)).all()[0][0],\n photos.count()]},\n {'name': 'Videos', 'color': '#397DAA',\n 'data': [videos.with_entities(func.sum(MediaFiles.size)).all()[0][0],\n videos.count()]}]\n return result","def type_of_errors(assignment) -> dict:\n\n errors = {}\n for problem in assignment.problems.all():\n for error in problem.errors.all():\n if error.error_type in errors:\n errors[error.error_type] += 1\n else:\n errors[error.error_type] = 1\n return errors","def describe_type(group, type_counter, describe=True):\n docs = conll04_parser.get_docs(group)\n count = {}\n for document in docs:\n cnt = type_counter(document)\n for key in cnt:\n if key not in count:\n count[key] = cnt[key]\n else:\n count[key] += cnt[key]\n if describe:\n print(\"Description of type in\", group)\n print(\"Total:\", sum(count.values()))\n for key in count:\n print(key, \":\", count[key])\n sns.barplot(list(count.values()), list(count.keys()))\n plt.show()\n # Return a map from entities to corresponding encoding numbers\n return dict(zip(count.keys(), range(len(count))))","def counts(self) -> dict:\n return Counter(self.sequence)","def count_issues(issues):\n counts = {issue: 0 for issue in ISSUE_TYPES}\n for (_, _, issue_type, _) in issues:\n counts[issue_type] += 1\n counts = sorted(counts.items(),\n key=lambda item: item[1],\n reverse=True)\n return counts","def subtype_occurences(self):\n\n subtype_counts = Counter()\n\n for seqkey,seqs in self.seqs.iteritems():\n for seq,seqentry in seqs.iteritems():\n\n subtype_counts[seqentry['subtype']] += 1\n\n return subtype_counts","def get_counts(self):\n self._update_counts()\n return self.failures, self.warnings, self.infos","def _getValueCounts(mapping):\n return Counter({k: len(v) for k, v in viewitems(mapping)})","def counts(self):\n counts = {\n 'total': self.app.db.jobs.count(),\n 'failed': self.app.db.jobs.find({'status': 'failed'}).count(),\n 'pending': self.app.db.jobs.find({'status': 'pending'}).count(),\n 'done': self.app.db.jobs.find({'status': 'done'}).count(),\n }\n return counts","def _count_shapes(self, shape_data : dict) -> dict:\n shape_count = {}\n for item in shape_data:\n item_shape_type = item.get('shapeType')\n if item_shape_type not in shape_count:\n shape_count[item_shape_type] = 1\n else:\n shape_count[item_shape_type] += 1\n return shape_count","def probe_counts(**kwargs):\n attributes = [\"ping_type\", \"os\", \"app_version\", \"app_build_id\", \"channel\"]\n\n return dict(\n attributes=\",\".join(attributes),\n aggregate_attributes=\"\"\"\n metric,\n metric_type,\n key\n \"\"\",\n aggregate_grouping=\"\"\"\n client_agg_type,\n agg_type\n \"\"\",\n # not boolean\n scalar_metric_types=\"\"\"\n \"counter\",\n \"quantity\",\n \"labeled_counter\",\n \"timespan\"\n \"\"\",\n boolean_metric_types=\"\"\"\n \"boolean\"\n \"\"\",\n **kwargs,\n )","def create_count_map(self) -> Dict[int, int]:\n res: Dict[int, int] = {}\n for sequence_data in self.model.values():\n sequence_data: NGramsSequence = cast(NGramsSequence, sequence_data)\n for count in sequence_data.next_count.values():\n count: int = cast(int, count)\n if count not in res:\n res[count] = 0\n res[count] += 1\n self.count_map = res\n logger.success('created count map')\n return res","def collect_type_freqs(self):\n tf.logging.info('collecting type_freq, mapping type_id -> # instances')\n self.type_freq = collections.defaultdict(int)\n for f in self.frames():\n if self.instance_of in f:\n self.type_freq[f[self.instance_of].id] += 1\n # not sure why this is needed - do some things have Null id's?\n del self.type_freq[None]","def count_assets(contents, filter_folders=False) -> TotalAssets:\n if filter_folders:\n sub_folders = [\n folder for folder in contents.get('folders', [])\n if folder.get('name').lower().strip() in FOLDER_NAMES\n ]\n else:\n sub_folders = contents.get('folders', [])\n\n total = TotalAssets(\n len(contents.get('images', [])) + sum(\n [len(folder.get('images', [])) for folder in sub_folders]\n ),\n len(contents.get('videos', [])) + sum(\n [len(folder.get('videos', [])) for folder in sub_folders]\n ),\n len(contents.get('other_files', [])) + sum(\n [len(folder.get('other_files', [])) for folder in sub_folders]\n )\n )\n\n return total","def commit_count(commit_info_dict):\n commit_counts = {}\n for release, commit_dict in commit_info_dict.items():\n commit_counts_per_release = {}\n for user_id, commit_list in commit_dict.items():\n commit_counts_per_release[user_id] = len(commit_list)\n commit_counts[release] = commit_counts_per_release\n return commit_counts","def getMaterialCounter():\r\n materialCounter = {}\r\n for group in bpy.data.groups:\r\n if utils.is_export_node(group.name):\r\n materialCounter[group.name] = 0\r\n return materialCounter","def getClassCounts(b):\n c = {k:0 for k in labels.keys()}\n for r in b:\n c[r[0]] += 1\n return c","def countit(objs):\n out = {}\n for el in objs:\n out[el] = 1 + out.get(el, 0)\n out = {k: v for k, v in out.items()}\n return out","def get_counts(self):\n counts = {}\n for document in self.docs:\n for word in document:\n if word not in counts.keys():\n counts[word] = 1\n else:\n counts[word] += 1\n return counts","def fetch_counts_for_release(stdout):\n # For Release builds `otool -ov` command generates output that is\n # different from Debug builds.\n # Parsing implemented in such a way:\n # 1. Parse test class names.\n # 2. If they are not in ignored list, parse test method names.\n # 3. Calculate test count per test class.\n test_counts = {}\n res = re.split(TEST_CLASS_RELEASE_APP_PATTERN, stdout)\n # Ignore 1st element in split since it does not have any test class data\n test_classes_output = res[1:]\n for test_class, class_output in zip(test_classes_output[0::2],\n test_classes_output[1::2]):\n if test_class in IGNORED_CLASSES:\n continue\n names = TEST_NAME_RELEASE_APP_PATTERN.findall(class_output)\n test_counts[test_class] = test_counts.get(test_class, 0) + len(set(names))\n\n return collections.Counter(test_counts)","def tag_counts(self, types=[]):\n if not types:\n types = self.tag_types\n for tag_type in types:\n print \"\\t%15s : %-10s\" % (tag_type, len(self.tag_dictionary[tag_type]))","def subtype_counts(node_set, G, log=False):\n subtypes = Counter()\n for n in node_set:\n subtype = G.node[n]['subtype']\n subtypes[subtype] += 1\n\n if log:\n for k, v in subtypes.items():\n subtypes[k] = np.log10(v)\n \n return subtypes","def query_transition_counts(ordered_pitch_types, query_filter):\n transition_counts = {}\n\n for first_pitch_type in ordered_pitch_types:\n transition_counts[first_pitch_type] = {}\n\n for second_pitch_type in ordered_pitch_types:\n count_query = PitchTransition.select().where(\n PitchTransition.first_pitch_type == first_pitch_type).where(\n PitchTransition.second_pitch_type == second_pitch_type)\n\n if query_filter:\n count_query = count_query.where(query_filter)\n\n transition_counts[first_pitch_type][second_pitch_type] = count_query.count()\n\n return transition_counts","def gives_stats():\n dict_count = {\n \"amenities\": storage.count(Amenity),\n \"cities\": storage.count(City),\n \"places\": storage.count(Place),\n \"reviews\": storage.count(Review),\n \"states\": storage.count(State),\n \"users\": storage.count(User)\n }\n return jsonify(dict_count)","def review_counts(stat_info_dict):\n review_counts = {}\n for release, stat_dict in stat_info_dict.items():\n review_counts_per_release = {}\n for key, stat in stat_dict.items():\n # review count\n review_counts_per_release[key] = stat['metric']\n review_counts[release] = review_counts_per_release\n return review_counts","def get_tray_type_stats(db_path: str) -> int:\n return get_db_count(db_path, 'company_data.db', 'tray_types')","def getCounts():\n for area in AREAS:\n print(area['name'])\n lat = area['lat']\n lng = area['lng']\n count = utils.getExtracted(countCrimes, lat, lng)\n print('count: %s' % count)\n if type(count) is list:\n area['count'] = count[0]\n return AREAS","def get_stats(filtered_paths : dict) -> dict:\n stats_dict = defaultdict(dict)\n for mag in filtered_paths.keys():\n for spec,paths in filtered_paths[mag].items():\n counter = Counter()\n for path in paths:\n img = cv2.imread(path, -1)\n count = Counter(list(img.ravel()))\n counter += count\n stats_dict[mag][spec] = counter\n print(mag)\n return stats_dict","def shopee_dict(quote, results=100):\n\n brands = {}\n total_items = 0\n for brand in get_brands(quote, results):\n if brand in brands:\n brands[brand] += 1\n else:\n brands[brand] = 1\n total_items += 1\n return brands, total_items","def pobj_counts(pcode_obj):\n pcode = (pcode_obj.asDict())['pcode'][0] # no multiple pcode blocks - no delimiter\n counts = {'galleries': 0, 'spreads': 0, 'layouts': 0, 'panelgroups': 0}\n # , 'panels': 0, 'skips': 0 }\n galleries = pcode.pop('gallery', '')\n counts['galleries'] = len(galleries)\n for gallery in galleries:\n spreads = gallery.pop('spread', '')\n counts['spreads'] += len(spreads)\n for spread in spreads:\n layouts = spread.pop('layout', '')\n counts['layouts'] += len(layouts)\n for layout in layouts:\n panelgroups = layout.pop('panelgroup', '')\n counts['panelgroups'] += len(panelgroups)\n return counts","def test_collect_incident_type_dependencies(self, module_repo):\n expected_result = {(\"AutoFocus\", True), (\"Volatility\", True)}\n\n test_input = [\n {\n \"Dummy Incident Type\": {\n \"name\": \"Dummy Incident Type\",\n \"fromversion\": \"5.0.0\",\n \"pack\": \"dummy_pack\",\n \"playbooks\": \"Autofocus Query Samples, Sessions and Tags\",\n \"scripts\": \"AnalyzeMemImage\",\n }\n }\n ]\n\n found_result = PackDependencies._collect_incidents_types_dependencies(\n pack_incidents_types=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert set(found_result) == set(expected_result)","def SummarizeResources(res_dict):\n result = {}\n for res in res_dict:\n result.setdefault(res['type'], []).append(res['name'])\n return result","def test_count_genomic_types(self):\n \n result, bed_result = parse_AS_STRUCTURE_dict(\"test\", clipper.test_dir())\n result = count_genomic_types(result)\n \n self.assertDictEqual(result, {\"CE:\" : 14})","def get_usage_count(equations):\n usage_count = {}\n for eq in equations:\n usage_count.setdefault(eq.lhs, 0)\n for var in eq.rhs.atoms(Variable):\n usage_count.setdefault(var, 0)\n usage_count[var] += 1\n return usage_count","def daily_article_counts(args: Dict[str, Any]) -> List[object]:\n query = [\n {\n \"$match\": {\n \"outlet\": {\"$in\": args[\"outlets\"]},\n \"publishedAt\": {\n \"$gte\": args[\"begin_date\"],\n \"$lt\": args[\"end_date\"] + timedelta(days=1),\n },\n }\n },\n {\n \"$project\": {\n \"publishedAt\": {\n \"$dateToString\": {\"format\": \"%Y-%m-%d\", \"date\": \"$publishedAt\"}\n },\n \"outlet\": 1.0,\n }\n },\n {\n \"$group\": {\n \"_id\": {\"publishedAt\": \"$publishedAt\", \"outlet\": \"$outlet\"},\n \"numArticles\": {\"$sum\": 1.0},\n }\n },\n {\n \"$project\": {\n \"_id\": 0.0,\n \"date\": {\n \"$dateFromString\": {\n \"dateString\": \"$_id.publishedAt\",\n \"format\": \"%Y-%m-%d\",\n }\n },\n \"outlet\": \"$_id.outlet\",\n \"numArticles\": 1.0,\n }\n },\n ]\n return query","def test_collect_indicator_type_dependencies(self, module_repo):\n expected_result = {\n # script dependencies\n (\"CommonScripts\", False),\n (\"Carbon_Black_Enterprise_Response\", False),\n }\n\n test_input = [\n {\n \"Dummy Indicator Type\": {\n \"name\": \"Dummy Indicator Type\",\n \"fromversion\": \"5.0.0\",\n \"pack\": \"dummy_pack\",\n \"integrations\": [\n \"abuse.ch SSL Blacklist Feed\",\n \"AbuseIPDB\",\n \"ActiveMQ\",\n ],\n \"scripts\": [\"AssignAnalystToIncident\", \"CBAlerts\"],\n }\n }\n ]\n\n found_result = PackDependencies._collect_indicators_types_dependencies(\n pack_indicators_types=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert set(found_result) == set(expected_result)","def get_contents(path : str) -> dict[str, dict[str, int]]:\n with open(path, \"r\") as f:\n lines = f.readlines();\n \n contents = {}\n\n # Could use regex here, but hardly seems necessary due to the input size.\n for line in lines:\n try:\n bag, contains = line.split(\" bags contain \");\n except:\n continue\n\n contents[bag] = Counter()\n if contains.startswith(\"no\"): continue\n\n # separate types\n for item in contains.split(\", \"):\n parts = item.split();\n color = parts[1] + \" \" + parts[2]\n count = int(parts[0])\n contents[bag][color] = count\n \n return contents","def count(self):\n freq = {}\n\n for desc in self.words:\n if desc in freq:\n freq[desc] += 1\n else:\n freq[desc] = 1\n\n return freq","def count_entity_doc(document):\n count = {}\n for line in document[1:]:\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\n if entity_type in count:\n count[entity_type] += 1\n else:\n count[entity_type] = 1\n return count","def count_genres(type_: str, value_=''):\n count = factory.get_elem_count(Genre, type_, value_)\n return count","def counts(self):\n\n counts = defaultdict(int)\n\n for i, geom in zip(self.tree_ids, self.tree):\n point_int = list(self.sindex.intersection(geom.bounds))\n if point_int:\n counts[i] += len(point_int)\n\n return dict(counts)","def stats():\n stats = {\n \"Amenity\": \"amenities\",\n \"City\": \"cities\",\n \"Place\": \"places\",\n \"Review\": \"reviews\",\n \"State\": \"states\",\n \"User\": \"users\"\n }\n\n stat = {name: storage.count(obj) for obj, name in stats.items()}\n return jsonify(stat)","def histogram_bucket_counts(**kwargs):\n attributes_list = [\"ping_type\", \"os\", \"app_version\", \"app_build_id\", \"channel\"]\n metric_attributes_list = [\"metric\", \"metric_type\", \"key\", \"agg_type\"]\n fixed_attributes = [\"app_version\", \"channel\"]\n cubed_attributes = [x for x in attributes_list if x not in fixed_attributes]\n return dict(\n attributes_list=attributes_list,\n attributes=\",\".join(attributes_list),\n cubed_attributes=cubed_attributes,\n attribute_combinations=compute_datacube_groupings(cubed_attributes),\n metric_attributes_list=metric_attributes_list,\n metric_attributes=\",\".join(metric_attributes_list),\n custom_distribution_metadata_list=get_custom_distribution_metadata(\"fenix\"),\n **kwargs,\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","def _create_word_count_dict(self):\n word_counts = dict()\n for wc in self.word_counts.all():\n word_counts[wc.word.name] = wc.count\n return word_counts","def fetch_test_counts(stdout, release=False):\n LOGGER.info(\"Ignored test classes: {}\".format(IGNORED_CLASSES))\n if release:\n LOGGER.info(\"Release build detected. Fetching count for release.\")\n return fetch_counts_for_release(stdout)\n\n return fetch_counts_for_debug(stdout)","def counts(sequence):\n # initialize the countainer\n count = defaultdict(int)\n # iterates through sequence elements\n for item in sequence:\n # if element not in counts add 0\n # else add 1\n count[item] = count.get(item, 0) + 1\n return dict(count)","def counts(url, key='author.email'):\n LOG.info('Getting counts', url=url, key=key)\n authors = GitTool.commits(url, key, include_defaults=False, result_format='flat_list')\n counts = defaultdict(lambda: 0)\n for x in authors:\n if key == 'author.email':\n x = re.sub(r'@.+', '', x)\n counts[x] += 1\n\n return OrderedDict(reversed(sorted(counts.items(), key=lambda x: x[1])))","def count_extracted(j_data):\n count = 0\n for record in j_data:\n tmp = {}\n desc = record['lcr_desc'].lower().split('/')\n title = desc[0]\n cat = category(title)\n if cat and 'location' in record:\n count += 1\n return count","def type_classes(self) -> Dict[str, int]:\n return {\n \"bg\": 0,\n \"neutrophil\": 1,\n \"epithelial\": 2,\n \"lymphocyte\": 3,\n \"plasma\": 4,\n \"eosinophil\": 5,\n \"connective\": 6,\n }","def get_counts_by_manufacturers(table):\n manufacturers_dict = {}\n for item in table:\n try:\n if item[2]:\n try:\n if item[2] in manufacturers_dict.keys():\n manufacturers_dict[item[2]] += 1\n else:\n manufacturers_dict[item[2]] = 1\n except IndexError:\n pass\n else:\n raise ValueError\n except ValueError:\n pass\n\n return manufacturers_dict","def get_bag_type_count(self, colour):\n count = 0\n for bag, quantity in self.bags:\n # This gets around the need to count oneself\n if bag.colour == colour:\n count += quantity\n count += bag.get_bag_type_count(colour) * quantity\n return count","def count_elements(seq) -> dict:\n hist = {}\n for i in seq:\n hist[i] = hist.get(i, 0) + 1\n return hist","def count_elements(seq) -> dict:\n hist = {}\n for i in seq:\n hist[i] = hist.get(i, 0) + 1\n return hist","def by_type(environments):\n types = {}\n for env in environments:\n et = env.environmentType\n options = types.setdefault(et.id, set())\n options.add(env.id)\n return types","def single_type_count(clothes_list, type):\n type_count = 0\n for garment in clothes_list:\n if garment.db.clothing_type:\n if garment.db.clothing_type == type:\n type_count += 1\n return type_count","def categorize (self):\n\n fout = defaultdict(list)\n\n # Flat lists of files to collect keyed by platform,category\n collect_files = dict()\n for platform in wanted_files:\n for category, flist in wanted_files[platform].items():\n for f in flist:\n collect_files[(platform,category,f)] = list()\n\n for a in self.artifacts:\n try:\n with zfile.ZFile(a.lpath, 'r') as zf:\n if os.path.splitext(a.lpath)[-1] == '.rpm':\n a.info['plat'] = 'rhel'\n\n platform = a.info['plat']\n if platform not in platforms:\n continue\n\n zfiles = zf.getnames()\n if len(zfiles) == 0:\n print('No files in %s?' % a)\n for category, flist in wanted_files[platform].items():\n for f in flist:\n matches = [(a,x) for x in zfiles if os.path.basename(x) == f]\n if len(matches) > 0:\n collect_files[(platform,category,f)] += matches\n fout[category] += matches\n\n except zfile.tarfile.ReadError as e:\n print('ignoring artifact: %s: %s' % (a.lpath, str(e)))\n\n # Verify that all wanted combinations were matched\n errors = 0\n for missing in [x for x in collect_files if len(collect_files[x]) == 0]:\n errors += 1\n print('ERROR: No matching artifact files for', missing)\n\n if errors > 0:\n raise Exception('Not all wanted files found in artifacts, see above.')\n return fout","def summary(self):\n summary = defaultdict(int)\n\n for r in self.results:\n summary[r.result] += 1\n\n return summary","def test_13_file_content_types_published(self):\n print (self.test_13_file_content_types_published.__doc__)\n\n kwargs = dict(start_date='2015-11-01',\n end_date='2016-03-01')\n stats_maker = StatsMakerFiles(**kwargs)\n r = stats_maker.get_datafile_content_type_counts_published()\n\n # check number of entries\n self.assertEqual(len(r.result_data['records']), 18)\n\n # check first listing\n first_listing = {'contenttype': u'application/octet-stream',\n 'percent_string': '65.1%',\n 'short_content_type': u'octet-stream',\n 'total_count': 255,\n 'type_count': 166}\n self.assertEqual(dict(r.result_data['records'][0]), first_listing)\n\n # check 3rd listing\n third_listing = {'contenttype': u'text/tab-separated-values',\n 'percent_string': '9.0%',\n 'short_content_type': u'tab-separated-values',\n 'total_count': 255,\n 'type_count': 23}\n self.assertEqual(r.result_data['records'][2], third_listing)","def count(self):\n count = {}\n\n for path, lines in self.lines_added.items():\n count[path] = count.get(path, 0) + sum(lines)\n\n for path, lines in self.lines_removed.items():\n count[path] = count.get(path, 0) + sum(lines)\n\n return count","def winners_per_type(self):\n winners = [winner[1] for winner in self.result]\n # making a list of the type of winners\n return Counter(winners)\n # Using the Counter tool from the standard library to count the\n # types in a dictionary","def get_counts(self, obj: User):\n uploader = obj.id\n public_count = Image.objects.filter(uploader=uploader, is_private=False, is_profile_image=False).count()\n private_count = Image.objects.filter(uploader=uploader, is_private=True, is_profile_image=False).count()\n liked_count = Image.objects.filter(likes__id=uploader).count()\n \n return {\n \"public\": public_count,\n \"private\": private_count,\n \"liked\": liked_count,\n }","def get_PM_filter_by_counts(request):\n import_file_id = request.GET.get('import_file_id', '')\n\n matched = BuildingSnapshot.objects.filter(\n import_file__pk=import_file_id,\n source_type__in=[2, 3],\n children__isnull=False\n ).count()\n unmatched = BuildingSnapshot.objects.filter(\n import_file__pk=import_file_id,\n source_type__in=[2, 3],\n children__isnull=True\n ).count()\n return {\n 'status': 'success',\n 'matched': matched,\n 'unmatched': unmatched,\n }","def counts(li):\n d={}\n for x in li:\n d[x]=d.get(x,0)+1\n return dict(sorted([x,d[x]] for x in d))","def countUMIs(barcode_dictionary):\n new_dict = {}\n for i in barcode_dictionary:\n \tnew_dict[i] = (sum(Counter(barcode_dictionary[i][1:]).values()), len(Counter(barcode_dictionary[i][1:]).keys()))\n return new_dict","def get_analytics_metadata(self) -> Dict[str, Any]:\n return {\n \"pinned\": self.pinned,\n \"item_count\": self.tiles.exclude(insight=None).count(),\n \"is_shared\": self.is_sharing_enabled,\n \"created_at\": self.created_at,\n \"has_description\": self.description != \"\",\n \"tags_count\": self.tagged_items.count(),\n }","def operation_counts(self) -> Dict[int, Dict[str, int]]:\n return self._operation_counts","def encoders_count(self):\r\n return self._get('encoders_count', {})","def count_tags(tags):\n counts = {}\n for tag_list in tags.values():\n for tag in tag_list:\n if tag in counts:\n counts[tag] += 1\n else:\n counts[tag] = 1\n return counts","def _libs_and_total_num_of_uniquely_aligned_reads(self):\n with open(\n self._pathcreator.read_alignments_stats_path\n ) as read_aligner_stats_fh:\n read_aligner_stats = json.loads(read_aligner_stats_fh.read())\n return dict(\n [\n (lib, values[\"stats_total\"][\"no_of_uniquely_aligned_reads\"])\n for lib, values in read_aligner_stats.items()\n ]\n )","def correct_counts():\n articles = mongo.db[app.config['ARTICLES_COLLECTION']]\n monitors = mongo.db[app.config['MONITORS_COLLECTION']]\n unique = articles.distinct('feed_source', dict())\n for link in unique:\n count = articles.count({'feed_source': link})\n monitors.update({'metadata.rss_link': link}, {'$set': {'hits': count}})","def _get_counts(self, X: np.ndarray) -> Dict[int, np.ndarray]:\n return {f: np.bincount(X[:, f].astype(int), minlength=n_cat) for f, n_cat in\n self.categories_per_feature.items()}","def count(self, **query):\n # This may be optimised into one query in the future.\n result = 0\n for product_type, count in self._do_count_by_product(query):\n result += count\n\n return result","def count(self):\n return {'count': self.collection.count()}","def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\n -> typ.Dict[str, int]:\n hist = collections.Counter()\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\n return hist","def fetch_counts_for_debug(stdout):\n test_names = TEST_NAMES_DEBUG_APP_PATTERN.findall(stdout)\n test_counts = collections.Counter(test_class for test_class, _ in test_names\n if test_class not in IGNORED_CLASSES)\n\n return test_counts","def upd_type_count(self, upd_type, ct_type):\n for hour in self.data_file.buckets:\n ct_type[hour] = Counter(pt['type'] for pt in self.data_file.buckets[hour])[upd_type]\n return ct_type"],"string":"[\n \"def count_freq(self, types=1):\\n count_dict = {}\\n if types == 1:\\n for cat in self.categories:\\n num_images = sum(\\n [1 for i in self.data['annotations'] if i['category_id'] == self.cats_idx[cat]])\\n count_dict[cat] = num_images\\n elif types == 2:\\n pass\\n\\n return count_dict\",\n \"def count_types_by_provider(cls):\\n counts = db.Dataset.aggregate([{'$group':{'_id':{'asset_type':'$services.asset_type',\\n 'data_provider':'$services.data_provider'},\\n 'cnt':{'$sum':1}}}])\\n\\n # transform into slightly friendlier structure. could likely do this in mongo but no point\\n retval = defaultdict(dict)\\n for val in counts:\\n try:\\n retval[val['_id']['data_provider'][0]][val['_id']['asset_type'][0]] = val['cnt']\\n except:\\n pass\\n\\n return dict(retval)\",\n \"def type_count():\\n types = []\\n for typ in Statistics.all_type():\\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\\n fix_types = []\\n for i in sorted(types, key=lambda k: k['y']):\\n if i['y'] != 0:\\n fix_types.append(i)\\n return jsonify(result=fix_types)\",\n \"def count_artifact_number(self, context, type_name=None):\\n session = api.get_session()\\n return api.count_artifact_number(context, session, type_name)\",\n \"def clothing_type_count(clothes_list):\\n types_count = {}\\n for garment in clothes_list:\\n if garment.db.clothing_type:\\n type = garment.db.clothing_type\\n if type not in types_count.keys():\\n types_count[type] = 1\\n else:\\n types_count[type] += 1\\n return types_count\",\n \"def count_types():\\n classes = {\\\"Amenity\\\": Amenity, \\\"City\\\": City,\\n \\\"Place\\\": Place, \\\"Review\\\": Review, \\\"State\\\": State, \\\"User\\\": User}\\n my_dict = {}\\n for key in classes.keys():\\n if (classes[key] == Amenity):\\n my_dict[\\\"amenities\\\"] = storage.count(classes[key])\\n elif (classes[key] == City):\\n my_dict[\\\"cities\\\"] = storage.count(classes[key])\\n elif (classes[key] == Place):\\n my_dict[\\\"places\\\"] = storage.count(classes[key])\\n elif (classes[key] == Review):\\n my_dict[\\\"reviews\\\"] = storage.count(classes[key])\\n elif (classes[key] == State):\\n my_dict[\\\"states\\\"] = storage.count(classes[key])\\n elif (classes[key] == User):\\n my_dict[\\\"users\\\"] = storage.count(classes[key])\\n return (jsonify(my_dict))\",\n \"def active_type_counts(self):\\n names = self.visible()\\n return {\\n 'total': names.count(),\\n 'personal': len([n for n in names if n.is_personal()]),\\n 'organization': len([n for n in names if n.is_organization()]),\\n 'event': len([n for n in names if n.is_event()]),\\n 'software': len([n for n in names if n.is_software()]),\\n 'building': len([n for n in names if n.is_building()])\\n }\",\n \"def summarize(self) -> Mapping[str, int]:\\n return dict(\\n compounds=self.count_compounds(),\\n side_effects=self.count_side_effects(),\\n indications=self.count_indications(),\\n umls=self.count_umls(),\\n )\",\n \"def _get_as_dict_count(self):\\n counter = Counter()\\n for product in self.products:\\n counter[product.id] += 1\\n return counter\",\n \"def artifact_types_get_req():\\n return {'status': 'success',\\n 'message': '',\\n 'types': Artifact.types()}\",\n \"def get_package_type_counts(dataset_name):\\n token = get_access_token()\\n\\n dataset_id = get_dataset_id(token, dataset_name)\\n\\n r = requests.get(f\\\"https://api.pennsieve.io/datasets/{dataset_id}/packageTypeCounts\\\", headers=create_request_headers(token))\\n r.raise_for_status()\\n\\n return r.json()\",\n \"def stats():\\n class_counts = {}\\n convert_dict = {\\n 'Amenity': 'amenities',\\n 'State': 'states',\\n 'City': 'cities',\\n 'User': 'users',\\n 'Place': 'places',\\n 'Review': 'reviews'\\n }\\n\\n for _class in convert_dict.keys():\\n class_counts[convert_dict[_class]] = storage.count(_class)\\n\\n return jsonify(class_counts)\",\n \"def get_total_counts(self):\\n ret = {}\\n all_loggers_count = 0\\n for logger, name_map in self.acc_map.items():\\n cur_logger_count = 0\\n ret[logger.name] = {}\\n for name, status_map in name_map.items():\\n cur_name_count = 0\\n ret[logger.name][name] = {}\\n for status, acc in status_map.items():\\n cur_count = acc.total_count\\n ret[logger.name][name][status] = cur_count\\n cur_name_count += cur_count\\n cur_logger_count += cur_count\\n all_loggers_count += cur_count\\n ret[logger.name][name]['__all__'] = cur_name_count\\n ret[logger.name]['__all__'] = cur_logger_count\\n ret['__all__'] = all_loggers_count\\n return ret\",\n \"def view_counts():\\n out = {}\\n for i in range(len(classes)):\\n out.update({decoded[i]: storage.count(classes[i])})\\n return out\",\n \"def get_resource_count(har_json):\\n entries = har_json['log']['entries']\\n\\n resource_type_counts = Counter()\\n\\n for entry in entries:\\n resource = entry['request']['url']\\n dirty_resource_type = resource.split('.')[-1]\\n resource_type = dirty_resource_type.split('?')[0] # Remove url params\\n if len(resource_type) > 4:\\n resource_type_counts['other'] += 1\\n # print 'Found other resource type: {0}'.format(resource_type)\\n else:\\n resource_type_counts[resource_type] += 1\\n\\n return resource_type_counts\",\n \"def count_items(fileinfos, type, name=\\\"\\\"):\\n names = [] \\n if is_filename(name):\\n # count all elements/attributes for one text\\n for nodeName in fileinfos[name][\\\"usage_\\\" + type].keys():\\n names.append(nodeName) \\n elif name == \\\"\\\":\\n # count all elements/attributes for all texts\\n for filename in fileinfos:\\n for nodeName in fileinfos[filename][\\\"usage_\\\" + type].keys():\\n names.append(nodeName)\\n \\n items_counted = {}\\n \\n if is_filename(name) or name == \\\"\\\":\\n for singleName in unique_names(names):\\n counter = 0\\n for file in fileinfos:\\n counter += fileinfos[file][\\\"usage_\\\" + type].get(singleName, 0)\\n items_counted[singleName] = counter\\n elif is_attname(name):\\n # count attribute usage for all texts\\n for file in fileinfos:\\n if name[1:] in fileinfos[file][\\\"usage_att\\\"].keys():\\n items_counted[file] = fileinfos[file][\\\"usage_att\\\"][name[1:]]\\n else:\\n # count element usage for all texts\\n for file in fileinfos:\\n if name in fileinfos[file][\\\"usage_el\\\"].keys():\\n items_counted[file] = fileinfos[file][\\\"usage_el\\\"][name]\\n return items_counted\",\n \"def get_all_dataset_counts(\\n self,\\n ) -> Dict[Tuple[str, int, int], int]:\\n res = self._engine.execute(\\n select(\\n [\\n PRODUCT.c.name,\\n TIME_OVERVIEW.c.start_day,\\n TIME_OVERVIEW.c.period_type,\\n TIME_OVERVIEW.c.dataset_count,\\n ]\\n )\\n .select_from(TIME_OVERVIEW.join(PRODUCT))\\n .where(TIME_OVERVIEW.c.product_ref == PRODUCT.c.id)\\n .order_by(\\n PRODUCT.c.name, TIME_OVERVIEW.c.start_day, TIME_OVERVIEW.c.period_type\\n )\\n )\\n\\n return {\\n (\\n r.name,\\n *TimePeriodOverview.from_flat_period_representation(\\n r.period_type, r.start_day\\n )[:2],\\n ): r.dataset_count\\n for r in res\\n }\",\n \"def get_types_count():\\n return len(type_dict.keys())\",\n \"def get_ntype_counts_map(ntypes, ntype_counts):\\n return dict(zip(ntypes, ntype_counts))\",\n \"def DatumTypeCount(self, logfilePath=\\\"/home/zhenyuan/CTI/ta1-trace-1-e5-official-1.bin.1.json\\\"):\\n with open(logfilePath) as logfile:\\n jsonlogs = logfile.readline()\\n\\n datumTypeSet = set()\\n datumTypeCount = dict()\\n while jsonlogs:\\n logs = json.loads(jsonlogs)\\n datumType = list(logs['datum'].keys())[0]\\n\\n if datumType not in datumTypeSet:\\n print(logs)\\n datumTypeCount[datumType] = 0\\n\\n datumTypeSet.add(datumType)\\n datumTypeCount[datumType] += 1\\n\\n jsonlogs = logfile.readline()\\n\\n return datumTypeSet\\n pass\",\n \"def number_objects():\\n classes = [Amenity, City, Place, Review, State, User]\\n names = [\\\"amenities\\\", \\\"cities\\\", \\\"places\\\", \\\"reviews\\\", \\\"states\\\", \\\"users\\\"]\\n\\n num_objs = {}\\n for i in range(len(classes)):\\n num_objs[names[i]] = storage.count(classes[i])\\n\\n return jsonify(num_objs)\",\n \"def apply(self):\\n counter = {}\\n for act in self.activities:\\n freq = []\\n for trace in self.log:\\n freq.append(len(self.project_trace(trace, [act])))\\n if not len(freq) == 0:\\n counter[act] = {'sum': sum(freq), 'min': min(freq),\\n 'max': max(freq)}\\n return counter\",\n \"def get_attribute_counts(self):\\n counts = defaultdict(int)\\n for attr in self:\\n counts[attr.name] += 1\\n\\n return dict(counts)\",\n \"def stats_data_by_type():\\n photos = db_session.query(MediaFiles.size).filter(MediaFiles.duration == 0)\\n videos = db_session.query(MediaFiles.size).filter(MediaFiles.duration > 0)\\n result = [{'name': 'Photos', 'color': '#76BCEB',\\n 'data': [photos.with_entities(func.sum(MediaFiles.size)).all()[0][0],\\n photos.count()]},\\n {'name': 'Videos', 'color': '#397DAA',\\n 'data': [videos.with_entities(func.sum(MediaFiles.size)).all()[0][0],\\n videos.count()]}]\\n return result\",\n \"def type_of_errors(assignment) -> dict:\\n\\n errors = {}\\n for problem in assignment.problems.all():\\n for error in problem.errors.all():\\n if error.error_type in errors:\\n errors[error.error_type] += 1\\n else:\\n errors[error.error_type] = 1\\n return errors\",\n \"def describe_type(group, type_counter, describe=True):\\n docs = conll04_parser.get_docs(group)\\n count = {}\\n for document in docs:\\n cnt = type_counter(document)\\n for key in cnt:\\n if key not in count:\\n count[key] = cnt[key]\\n else:\\n count[key] += cnt[key]\\n if describe:\\n print(\\\"Description of type in\\\", group)\\n print(\\\"Total:\\\", sum(count.values()))\\n for key in count:\\n print(key, \\\":\\\", count[key])\\n sns.barplot(list(count.values()), list(count.keys()))\\n plt.show()\\n # Return a map from entities to corresponding encoding numbers\\n return dict(zip(count.keys(), range(len(count))))\",\n \"def counts(self) -> dict:\\n return Counter(self.sequence)\",\n \"def count_issues(issues):\\n counts = {issue: 0 for issue in ISSUE_TYPES}\\n for (_, _, issue_type, _) in issues:\\n counts[issue_type] += 1\\n counts = sorted(counts.items(),\\n key=lambda item: item[1],\\n reverse=True)\\n return counts\",\n \"def subtype_occurences(self):\\n\\n subtype_counts = Counter()\\n\\n for seqkey,seqs in self.seqs.iteritems():\\n for seq,seqentry in seqs.iteritems():\\n\\n subtype_counts[seqentry['subtype']] += 1\\n\\n return subtype_counts\",\n \"def get_counts(self):\\n self._update_counts()\\n return self.failures, self.warnings, self.infos\",\n \"def _getValueCounts(mapping):\\n return Counter({k: len(v) for k, v in viewitems(mapping)})\",\n \"def counts(self):\\n counts = {\\n 'total': self.app.db.jobs.count(),\\n 'failed': self.app.db.jobs.find({'status': 'failed'}).count(),\\n 'pending': self.app.db.jobs.find({'status': 'pending'}).count(),\\n 'done': self.app.db.jobs.find({'status': 'done'}).count(),\\n }\\n return counts\",\n \"def _count_shapes(self, shape_data : dict) -> dict:\\n shape_count = {}\\n for item in shape_data:\\n item_shape_type = item.get('shapeType')\\n if item_shape_type not in shape_count:\\n shape_count[item_shape_type] = 1\\n else:\\n shape_count[item_shape_type] += 1\\n return shape_count\",\n \"def probe_counts(**kwargs):\\n attributes = [\\\"ping_type\\\", \\\"os\\\", \\\"app_version\\\", \\\"app_build_id\\\", \\\"channel\\\"]\\n\\n return dict(\\n attributes=\\\",\\\".join(attributes),\\n aggregate_attributes=\\\"\\\"\\\"\\n metric,\\n metric_type,\\n key\\n \\\"\\\"\\\",\\n aggregate_grouping=\\\"\\\"\\\"\\n client_agg_type,\\n agg_type\\n \\\"\\\"\\\",\\n # not boolean\\n scalar_metric_types=\\\"\\\"\\\"\\n \\\"counter\\\",\\n \\\"quantity\\\",\\n \\\"labeled_counter\\\",\\n \\\"timespan\\\"\\n \\\"\\\"\\\",\\n boolean_metric_types=\\\"\\\"\\\"\\n \\\"boolean\\\"\\n \\\"\\\"\\\",\\n **kwargs,\\n )\",\n \"def create_count_map(self) -> Dict[int, int]:\\n res: Dict[int, int] = {}\\n for sequence_data in self.model.values():\\n sequence_data: NGramsSequence = cast(NGramsSequence, sequence_data)\\n for count in sequence_data.next_count.values():\\n count: int = cast(int, count)\\n if count not in res:\\n res[count] = 0\\n res[count] += 1\\n self.count_map = res\\n logger.success('created count map')\\n return res\",\n \"def collect_type_freqs(self):\\n tf.logging.info('collecting type_freq, mapping type_id -> # instances')\\n self.type_freq = collections.defaultdict(int)\\n for f in self.frames():\\n if self.instance_of in f:\\n self.type_freq[f[self.instance_of].id] += 1\\n # not sure why this is needed - do some things have Null id's?\\n del self.type_freq[None]\",\n \"def count_assets(contents, filter_folders=False) -> TotalAssets:\\n if filter_folders:\\n sub_folders = [\\n folder for folder in contents.get('folders', [])\\n if folder.get('name').lower().strip() in FOLDER_NAMES\\n ]\\n else:\\n sub_folders = contents.get('folders', [])\\n\\n total = TotalAssets(\\n len(contents.get('images', [])) + sum(\\n [len(folder.get('images', [])) for folder in sub_folders]\\n ),\\n len(contents.get('videos', [])) + sum(\\n [len(folder.get('videos', [])) for folder in sub_folders]\\n ),\\n len(contents.get('other_files', [])) + sum(\\n [len(folder.get('other_files', [])) for folder in sub_folders]\\n )\\n )\\n\\n return total\",\n \"def commit_count(commit_info_dict):\\n commit_counts = {}\\n for release, commit_dict in commit_info_dict.items():\\n commit_counts_per_release = {}\\n for user_id, commit_list in commit_dict.items():\\n commit_counts_per_release[user_id] = len(commit_list)\\n commit_counts[release] = commit_counts_per_release\\n return commit_counts\",\n \"def getMaterialCounter():\\r\\n materialCounter = {}\\r\\n for group in bpy.data.groups:\\r\\n if utils.is_export_node(group.name):\\r\\n materialCounter[group.name] = 0\\r\\n return materialCounter\",\n \"def getClassCounts(b):\\n c = {k:0 for k in labels.keys()}\\n for r in b:\\n c[r[0]] += 1\\n return c\",\n \"def countit(objs):\\n out = {}\\n for el in objs:\\n out[el] = 1 + out.get(el, 0)\\n out = {k: v for k, v in out.items()}\\n return out\",\n \"def get_counts(self):\\n counts = {}\\n for document in self.docs:\\n for word in document:\\n if word not in counts.keys():\\n counts[word] = 1\\n else:\\n counts[word] += 1\\n return counts\",\n \"def fetch_counts_for_release(stdout):\\n # For Release builds `otool -ov` command generates output that is\\n # different from Debug builds.\\n # Parsing implemented in such a way:\\n # 1. Parse test class names.\\n # 2. If they are not in ignored list, parse test method names.\\n # 3. Calculate test count per test class.\\n test_counts = {}\\n res = re.split(TEST_CLASS_RELEASE_APP_PATTERN, stdout)\\n # Ignore 1st element in split since it does not have any test class data\\n test_classes_output = res[1:]\\n for test_class, class_output in zip(test_classes_output[0::2],\\n test_classes_output[1::2]):\\n if test_class in IGNORED_CLASSES:\\n continue\\n names = TEST_NAME_RELEASE_APP_PATTERN.findall(class_output)\\n test_counts[test_class] = test_counts.get(test_class, 0) + len(set(names))\\n\\n return collections.Counter(test_counts)\",\n \"def tag_counts(self, types=[]):\\n if not types:\\n types = self.tag_types\\n for tag_type in types:\\n print \\\"\\\\t%15s : %-10s\\\" % (tag_type, len(self.tag_dictionary[tag_type]))\",\n \"def subtype_counts(node_set, G, log=False):\\n subtypes = Counter()\\n for n in node_set:\\n subtype = G.node[n]['subtype']\\n subtypes[subtype] += 1\\n\\n if log:\\n for k, v in subtypes.items():\\n subtypes[k] = np.log10(v)\\n \\n return subtypes\",\n \"def query_transition_counts(ordered_pitch_types, query_filter):\\n transition_counts = {}\\n\\n for first_pitch_type in ordered_pitch_types:\\n transition_counts[first_pitch_type] = {}\\n\\n for second_pitch_type in ordered_pitch_types:\\n count_query = PitchTransition.select().where(\\n PitchTransition.first_pitch_type == first_pitch_type).where(\\n PitchTransition.second_pitch_type == second_pitch_type)\\n\\n if query_filter:\\n count_query = count_query.where(query_filter)\\n\\n transition_counts[first_pitch_type][second_pitch_type] = count_query.count()\\n\\n return transition_counts\",\n \"def gives_stats():\\n dict_count = {\\n \\\"amenities\\\": storage.count(Amenity),\\n \\\"cities\\\": storage.count(City),\\n \\\"places\\\": storage.count(Place),\\n \\\"reviews\\\": storage.count(Review),\\n \\\"states\\\": storage.count(State),\\n \\\"users\\\": storage.count(User)\\n }\\n return jsonify(dict_count)\",\n \"def review_counts(stat_info_dict):\\n review_counts = {}\\n for release, stat_dict in stat_info_dict.items():\\n review_counts_per_release = {}\\n for key, stat in stat_dict.items():\\n # review count\\n review_counts_per_release[key] = stat['metric']\\n review_counts[release] = review_counts_per_release\\n return review_counts\",\n \"def get_tray_type_stats(db_path: str) -> int:\\n return get_db_count(db_path, 'company_data.db', 'tray_types')\",\n \"def getCounts():\\n for area in AREAS:\\n print(area['name'])\\n lat = area['lat']\\n lng = area['lng']\\n count = utils.getExtracted(countCrimes, lat, lng)\\n print('count: %s' % count)\\n if type(count) is list:\\n area['count'] = count[0]\\n return AREAS\",\n \"def get_stats(filtered_paths : dict) -> dict:\\n stats_dict = defaultdict(dict)\\n for mag in filtered_paths.keys():\\n for spec,paths in filtered_paths[mag].items():\\n counter = Counter()\\n for path in paths:\\n img = cv2.imread(path, -1)\\n count = Counter(list(img.ravel()))\\n counter += count\\n stats_dict[mag][spec] = counter\\n print(mag)\\n return stats_dict\",\n \"def shopee_dict(quote, results=100):\\n\\n brands = {}\\n total_items = 0\\n for brand in get_brands(quote, results):\\n if brand in brands:\\n brands[brand] += 1\\n else:\\n brands[brand] = 1\\n total_items += 1\\n return brands, total_items\",\n \"def pobj_counts(pcode_obj):\\n pcode = (pcode_obj.asDict())['pcode'][0] # no multiple pcode blocks - no delimiter\\n counts = {'galleries': 0, 'spreads': 0, 'layouts': 0, 'panelgroups': 0}\\n # , 'panels': 0, 'skips': 0 }\\n galleries = pcode.pop('gallery', '')\\n counts['galleries'] = len(galleries)\\n for gallery in galleries:\\n spreads = gallery.pop('spread', '')\\n counts['spreads'] += len(spreads)\\n for spread in spreads:\\n layouts = spread.pop('layout', '')\\n counts['layouts'] += len(layouts)\\n for layout in layouts:\\n panelgroups = layout.pop('panelgroup', '')\\n counts['panelgroups'] += len(panelgroups)\\n return counts\",\n \"def test_collect_incident_type_dependencies(self, module_repo):\\n expected_result = {(\\\"AutoFocus\\\", True), (\\\"Volatility\\\", True)}\\n\\n test_input = [\\n {\\n \\\"Dummy Incident Type\\\": {\\n \\\"name\\\": \\\"Dummy Incident Type\\\",\\n \\\"fromversion\\\": \\\"5.0.0\\\",\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"playbooks\\\": \\\"Autofocus Query Samples, Sessions and Tags\\\",\\n \\\"scripts\\\": \\\"AnalyzeMemImage\\\",\\n }\\n }\\n ]\\n\\n found_result = PackDependencies._collect_incidents_types_dependencies(\\n pack_incidents_types=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert set(found_result) == set(expected_result)\",\n \"def SummarizeResources(res_dict):\\n result = {}\\n for res in res_dict:\\n result.setdefault(res['type'], []).append(res['name'])\\n return result\",\n \"def test_count_genomic_types(self):\\n \\n result, bed_result = parse_AS_STRUCTURE_dict(\\\"test\\\", clipper.test_dir())\\n result = count_genomic_types(result)\\n \\n self.assertDictEqual(result, {\\\"CE:\\\" : 14})\",\n \"def get_usage_count(equations):\\n usage_count = {}\\n for eq in equations:\\n usage_count.setdefault(eq.lhs, 0)\\n for var in eq.rhs.atoms(Variable):\\n usage_count.setdefault(var, 0)\\n usage_count[var] += 1\\n return usage_count\",\n \"def daily_article_counts(args: Dict[str, Any]) -> List[object]:\\n query = [\\n {\\n \\\"$match\\\": {\\n \\\"outlet\\\": {\\\"$in\\\": args[\\\"outlets\\\"]},\\n \\\"publishedAt\\\": {\\n \\\"$gte\\\": args[\\\"begin_date\\\"],\\n \\\"$lt\\\": args[\\\"end_date\\\"] + timedelta(days=1),\\n },\\n }\\n },\\n {\\n \\\"$project\\\": {\\n \\\"publishedAt\\\": {\\n \\\"$dateToString\\\": {\\\"format\\\": \\\"%Y-%m-%d\\\", \\\"date\\\": \\\"$publishedAt\\\"}\\n },\\n \\\"outlet\\\": 1.0,\\n }\\n },\\n {\\n \\\"$group\\\": {\\n \\\"_id\\\": {\\\"publishedAt\\\": \\\"$publishedAt\\\", \\\"outlet\\\": \\\"$outlet\\\"},\\n \\\"numArticles\\\": {\\\"$sum\\\": 1.0},\\n }\\n },\\n {\\n \\\"$project\\\": {\\n \\\"_id\\\": 0.0,\\n \\\"date\\\": {\\n \\\"$dateFromString\\\": {\\n \\\"dateString\\\": \\\"$_id.publishedAt\\\",\\n \\\"format\\\": \\\"%Y-%m-%d\\\",\\n }\\n },\\n \\\"outlet\\\": \\\"$_id.outlet\\\",\\n \\\"numArticles\\\": 1.0,\\n }\\n },\\n ]\\n return query\",\n \"def test_collect_indicator_type_dependencies(self, module_repo):\\n expected_result = {\\n # script dependencies\\n (\\\"CommonScripts\\\", False),\\n (\\\"Carbon_Black_Enterprise_Response\\\", False),\\n }\\n\\n test_input = [\\n {\\n \\\"Dummy Indicator Type\\\": {\\n \\\"name\\\": \\\"Dummy Indicator Type\\\",\\n \\\"fromversion\\\": \\\"5.0.0\\\",\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"integrations\\\": [\\n \\\"abuse.ch SSL Blacklist Feed\\\",\\n \\\"AbuseIPDB\\\",\\n \\\"ActiveMQ\\\",\\n ],\\n \\\"scripts\\\": [\\\"AssignAnalystToIncident\\\", \\\"CBAlerts\\\"],\\n }\\n }\\n ]\\n\\n found_result = PackDependencies._collect_indicators_types_dependencies(\\n pack_indicators_types=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert set(found_result) == set(expected_result)\",\n \"def get_contents(path : str) -> dict[str, dict[str, int]]:\\n with open(path, \\\"r\\\") as f:\\n lines = f.readlines();\\n \\n contents = {}\\n\\n # Could use regex here, but hardly seems necessary due to the input size.\\n for line in lines:\\n try:\\n bag, contains = line.split(\\\" bags contain \\\");\\n except:\\n continue\\n\\n contents[bag] = Counter()\\n if contains.startswith(\\\"no\\\"): continue\\n\\n # separate types\\n for item in contains.split(\\\", \\\"):\\n parts = item.split();\\n color = parts[1] + \\\" \\\" + parts[2]\\n count = int(parts[0])\\n contents[bag][color] = count\\n \\n return contents\",\n \"def count(self):\\n freq = {}\\n\\n for desc in self.words:\\n if desc in freq:\\n freq[desc] += 1\\n else:\\n freq[desc] = 1\\n\\n return freq\",\n \"def count_entity_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\\n if entity_type in count:\\n count[entity_type] += 1\\n else:\\n count[entity_type] = 1\\n return count\",\n \"def count_genres(type_: str, value_=''):\\n count = factory.get_elem_count(Genre, type_, value_)\\n return count\",\n \"def counts(self):\\n\\n counts = defaultdict(int)\\n\\n for i, geom in zip(self.tree_ids, self.tree):\\n point_int = list(self.sindex.intersection(geom.bounds))\\n if point_int:\\n counts[i] += len(point_int)\\n\\n return dict(counts)\",\n \"def stats():\\n stats = {\\n \\\"Amenity\\\": \\\"amenities\\\",\\n \\\"City\\\": \\\"cities\\\",\\n \\\"Place\\\": \\\"places\\\",\\n \\\"Review\\\": \\\"reviews\\\",\\n \\\"State\\\": \\\"states\\\",\\n \\\"User\\\": \\\"users\\\"\\n }\\n\\n stat = {name: storage.count(obj) for obj, name in stats.items()}\\n return jsonify(stat)\",\n \"def histogram_bucket_counts(**kwargs):\\n attributes_list = [\\\"ping_type\\\", \\\"os\\\", \\\"app_version\\\", \\\"app_build_id\\\", \\\"channel\\\"]\\n metric_attributes_list = [\\\"metric\\\", \\\"metric_type\\\", \\\"key\\\", \\\"agg_type\\\"]\\n fixed_attributes = [\\\"app_version\\\", \\\"channel\\\"]\\n cubed_attributes = [x for x in attributes_list if x not in fixed_attributes]\\n return dict(\\n attributes_list=attributes_list,\\n attributes=\\\",\\\".join(attributes_list),\\n cubed_attributes=cubed_attributes,\\n attribute_combinations=compute_datacube_groupings(cubed_attributes),\\n metric_attributes_list=metric_attributes_list,\\n metric_attributes=\\\",\\\".join(metric_attributes_list),\\n custom_distribution_metadata_list=get_custom_distribution_metadata(\\\"fenix\\\"),\\n **kwargs,\\n )\",\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 _create_word_count_dict(self):\\n word_counts = dict()\\n for wc in self.word_counts.all():\\n word_counts[wc.word.name] = wc.count\\n return word_counts\",\n \"def fetch_test_counts(stdout, release=False):\\n LOGGER.info(\\\"Ignored test classes: {}\\\".format(IGNORED_CLASSES))\\n if release:\\n LOGGER.info(\\\"Release build detected. Fetching count for release.\\\")\\n return fetch_counts_for_release(stdout)\\n\\n return fetch_counts_for_debug(stdout)\",\n \"def counts(sequence):\\n # initialize the countainer\\n count = defaultdict(int)\\n # iterates through sequence elements\\n for item in sequence:\\n # if element not in counts add 0\\n # else add 1\\n count[item] = count.get(item, 0) + 1\\n return dict(count)\",\n \"def counts(url, key='author.email'):\\n LOG.info('Getting counts', url=url, key=key)\\n authors = GitTool.commits(url, key, include_defaults=False, result_format='flat_list')\\n counts = defaultdict(lambda: 0)\\n for x in authors:\\n if key == 'author.email':\\n x = re.sub(r'@.+', '', x)\\n counts[x] += 1\\n\\n return OrderedDict(reversed(sorted(counts.items(), key=lambda x: x[1])))\",\n \"def count_extracted(j_data):\\n count = 0\\n for record in j_data:\\n tmp = {}\\n desc = record['lcr_desc'].lower().split('/')\\n title = desc[0]\\n cat = category(title)\\n if cat and 'location' in record:\\n count += 1\\n return count\",\n \"def type_classes(self) -> Dict[str, int]:\\n return {\\n \\\"bg\\\": 0,\\n \\\"neutrophil\\\": 1,\\n \\\"epithelial\\\": 2,\\n \\\"lymphocyte\\\": 3,\\n \\\"plasma\\\": 4,\\n \\\"eosinophil\\\": 5,\\n \\\"connective\\\": 6,\\n }\",\n \"def get_counts_by_manufacturers(table):\\n manufacturers_dict = {}\\n for item in table:\\n try:\\n if item[2]:\\n try:\\n if item[2] in manufacturers_dict.keys():\\n manufacturers_dict[item[2]] += 1\\n else:\\n manufacturers_dict[item[2]] = 1\\n except IndexError:\\n pass\\n else:\\n raise ValueError\\n except ValueError:\\n pass\\n\\n return manufacturers_dict\",\n \"def get_bag_type_count(self, colour):\\n count = 0\\n for bag, quantity in self.bags:\\n # This gets around the need to count oneself\\n if bag.colour == colour:\\n count += quantity\\n count += bag.get_bag_type_count(colour) * quantity\\n return count\",\n \"def count_elements(seq) -> dict:\\n hist = {}\\n for i in seq:\\n hist[i] = hist.get(i, 0) + 1\\n return hist\",\n \"def count_elements(seq) -> dict:\\n hist = {}\\n for i in seq:\\n hist[i] = hist.get(i, 0) + 1\\n return hist\",\n \"def by_type(environments):\\n types = {}\\n for env in environments:\\n et = env.environmentType\\n options = types.setdefault(et.id, set())\\n options.add(env.id)\\n return types\",\n \"def single_type_count(clothes_list, type):\\n type_count = 0\\n for garment in clothes_list:\\n if garment.db.clothing_type:\\n if garment.db.clothing_type == type:\\n type_count += 1\\n return type_count\",\n \"def categorize (self):\\n\\n fout = defaultdict(list)\\n\\n # Flat lists of files to collect keyed by platform,category\\n collect_files = dict()\\n for platform in wanted_files:\\n for category, flist in wanted_files[platform].items():\\n for f in flist:\\n collect_files[(platform,category,f)] = list()\\n\\n for a in self.artifacts:\\n try:\\n with zfile.ZFile(a.lpath, 'r') as zf:\\n if os.path.splitext(a.lpath)[-1] == '.rpm':\\n a.info['plat'] = 'rhel'\\n\\n platform = a.info['plat']\\n if platform not in platforms:\\n continue\\n\\n zfiles = zf.getnames()\\n if len(zfiles) == 0:\\n print('No files in %s?' % a)\\n for category, flist in wanted_files[platform].items():\\n for f in flist:\\n matches = [(a,x) for x in zfiles if os.path.basename(x) == f]\\n if len(matches) > 0:\\n collect_files[(platform,category,f)] += matches\\n fout[category] += matches\\n\\n except zfile.tarfile.ReadError as e:\\n print('ignoring artifact: %s: %s' % (a.lpath, str(e)))\\n\\n # Verify that all wanted combinations were matched\\n errors = 0\\n for missing in [x for x in collect_files if len(collect_files[x]) == 0]:\\n errors += 1\\n print('ERROR: No matching artifact files for', missing)\\n\\n if errors > 0:\\n raise Exception('Not all wanted files found in artifacts, see above.')\\n return fout\",\n \"def summary(self):\\n summary = defaultdict(int)\\n\\n for r in self.results:\\n summary[r.result] += 1\\n\\n return summary\",\n \"def test_13_file_content_types_published(self):\\n print (self.test_13_file_content_types_published.__doc__)\\n\\n kwargs = dict(start_date='2015-11-01',\\n end_date='2016-03-01')\\n stats_maker = StatsMakerFiles(**kwargs)\\n r = stats_maker.get_datafile_content_type_counts_published()\\n\\n # check number of entries\\n self.assertEqual(len(r.result_data['records']), 18)\\n\\n # check first listing\\n first_listing = {'contenttype': u'application/octet-stream',\\n 'percent_string': '65.1%',\\n 'short_content_type': u'octet-stream',\\n 'total_count': 255,\\n 'type_count': 166}\\n self.assertEqual(dict(r.result_data['records'][0]), first_listing)\\n\\n # check 3rd listing\\n third_listing = {'contenttype': u'text/tab-separated-values',\\n 'percent_string': '9.0%',\\n 'short_content_type': u'tab-separated-values',\\n 'total_count': 255,\\n 'type_count': 23}\\n self.assertEqual(r.result_data['records'][2], third_listing)\",\n \"def count(self):\\n count = {}\\n\\n for path, lines in self.lines_added.items():\\n count[path] = count.get(path, 0) + sum(lines)\\n\\n for path, lines in self.lines_removed.items():\\n count[path] = count.get(path, 0) + sum(lines)\\n\\n return count\",\n \"def winners_per_type(self):\\n winners = [winner[1] for winner in self.result]\\n # making a list of the type of winners\\n return Counter(winners)\\n # Using the Counter tool from the standard library to count the\\n # types in a dictionary\",\n \"def get_counts(self, obj: User):\\n uploader = obj.id\\n public_count = Image.objects.filter(uploader=uploader, is_private=False, is_profile_image=False).count()\\n private_count = Image.objects.filter(uploader=uploader, is_private=True, is_profile_image=False).count()\\n liked_count = Image.objects.filter(likes__id=uploader).count()\\n \\n return {\\n \\\"public\\\": public_count,\\n \\\"private\\\": private_count,\\n \\\"liked\\\": liked_count,\\n }\",\n \"def get_PM_filter_by_counts(request):\\n import_file_id = request.GET.get('import_file_id', '')\\n\\n matched = BuildingSnapshot.objects.filter(\\n import_file__pk=import_file_id,\\n source_type__in=[2, 3],\\n children__isnull=False\\n ).count()\\n unmatched = BuildingSnapshot.objects.filter(\\n import_file__pk=import_file_id,\\n source_type__in=[2, 3],\\n children__isnull=True\\n ).count()\\n return {\\n 'status': 'success',\\n 'matched': matched,\\n 'unmatched': unmatched,\\n }\",\n \"def counts(li):\\n d={}\\n for x in li:\\n d[x]=d.get(x,0)+1\\n return dict(sorted([x,d[x]] for x in d))\",\n \"def countUMIs(barcode_dictionary):\\n new_dict = {}\\n for i in barcode_dictionary:\\n \\tnew_dict[i] = (sum(Counter(barcode_dictionary[i][1:]).values()), len(Counter(barcode_dictionary[i][1:]).keys()))\\n return new_dict\",\n \"def get_analytics_metadata(self) -> Dict[str, Any]:\\n return {\\n \\\"pinned\\\": self.pinned,\\n \\\"item_count\\\": self.tiles.exclude(insight=None).count(),\\n \\\"is_shared\\\": self.is_sharing_enabled,\\n \\\"created_at\\\": self.created_at,\\n \\\"has_description\\\": self.description != \\\"\\\",\\n \\\"tags_count\\\": self.tagged_items.count(),\\n }\",\n \"def operation_counts(self) -> Dict[int, Dict[str, int]]:\\n return self._operation_counts\",\n \"def encoders_count(self):\\r\\n return self._get('encoders_count', {})\",\n \"def count_tags(tags):\\n counts = {}\\n for tag_list in tags.values():\\n for tag in tag_list:\\n if tag in counts:\\n counts[tag] += 1\\n else:\\n counts[tag] = 1\\n return counts\",\n \"def _libs_and_total_num_of_uniquely_aligned_reads(self):\\n with open(\\n self._pathcreator.read_alignments_stats_path\\n ) as read_aligner_stats_fh:\\n read_aligner_stats = json.loads(read_aligner_stats_fh.read())\\n return dict(\\n [\\n (lib, values[\\\"stats_total\\\"][\\\"no_of_uniquely_aligned_reads\\\"])\\n for lib, values in read_aligner_stats.items()\\n ]\\n )\",\n \"def correct_counts():\\n articles = mongo.db[app.config['ARTICLES_COLLECTION']]\\n monitors = mongo.db[app.config['MONITORS_COLLECTION']]\\n unique = articles.distinct('feed_source', dict())\\n for link in unique:\\n count = articles.count({'feed_source': link})\\n monitors.update({'metadata.rss_link': link}, {'$set': {'hits': count}})\",\n \"def _get_counts(self, X: np.ndarray) -> Dict[int, np.ndarray]:\\n return {f: np.bincount(X[:, f].astype(int), minlength=n_cat) for f, n_cat in\\n self.categories_per_feature.items()}\",\n \"def count(self, **query):\\n # This may be optimised into one query in the future.\\n result = 0\\n for product_type, count in self._do_count_by_product(query):\\n result += count\\n\\n return result\",\n \"def count(self):\\n return {'count': self.collection.count()}\",\n \"def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\\\\n -> typ.Dict[str, int]:\\n hist = collections.Counter()\\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\\n return hist\",\n \"def fetch_counts_for_debug(stdout):\\n test_names = TEST_NAMES_DEBUG_APP_PATTERN.findall(stdout)\\n test_counts = collections.Counter(test_class for test_class, _ in test_names\\n if test_class not in IGNORED_CLASSES)\\n\\n return test_counts\",\n \"def upd_type_count(self, upd_type, ct_type):\\n for hour in self.data_file.buckets:\\n ct_type[hour] = Counter(pt['type'] for pt in self.data_file.buckets[hour])[upd_type]\\n return ct_type\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66775286","0.6509573","0.645103","0.64237165","0.6420531","0.6405249","0.6346786","0.62873185","0.6284339","0.6173281","0.6121569","0.60898113","0.606048","0.5977172","0.5975826","0.5950914","0.5877489","0.5843365","0.5820288","0.5796875","0.5769143","0.573489","0.5724567","0.571147","0.5699036","0.56926745","0.5679133","0.5669717","0.5665488","0.5653084","0.5637848","0.5618428","0.5597329","0.55965334","0.5580748","0.5572239","0.55513537","0.5525329","0.5512218","0.55040383","0.5503849","0.55016327","0.5496972","0.5494969","0.54913235","0.54717356","0.54710543","0.54680324","0.5463595","0.54632014","0.5456655","0.5432586","0.5431211","0.5390512","0.53814507","0.53531635","0.5348064","0.5329896","0.5327601","0.5320248","0.53028214","0.52918303","0.5291812","0.5283449","0.528083","0.52756965","0.52699065","0.52694863","0.5266493","0.52603567","0.52536565","0.52522147","0.5248579","0.5248264","0.52395904","0.5236293","0.5236293","0.523429","0.523282","0.52271056","0.5225341","0.5224034","0.52123666","0.5210026","0.51937366","0.5192825","0.51921606","0.51917565","0.5187125","0.51834214","0.51770663","0.5160041","0.51565856","0.5155183","0.51528865","0.51519454","0.5150073","0.5144994","0.51432085","0.5140121"],"string":"[\n \"0.66775286\",\n \"0.6509573\",\n \"0.645103\",\n \"0.64237165\",\n \"0.6420531\",\n \"0.6405249\",\n \"0.6346786\",\n \"0.62873185\",\n \"0.6284339\",\n \"0.6173281\",\n \"0.6121569\",\n \"0.60898113\",\n \"0.606048\",\n \"0.5977172\",\n \"0.5975826\",\n \"0.5950914\",\n \"0.5877489\",\n \"0.5843365\",\n \"0.5820288\",\n \"0.5796875\",\n \"0.5769143\",\n \"0.573489\",\n \"0.5724567\",\n \"0.571147\",\n \"0.5699036\",\n \"0.56926745\",\n \"0.5679133\",\n \"0.5669717\",\n \"0.5665488\",\n \"0.5653084\",\n \"0.5637848\",\n \"0.5618428\",\n \"0.5597329\",\n \"0.55965334\",\n \"0.5580748\",\n \"0.5572239\",\n \"0.55513537\",\n \"0.5525329\",\n \"0.5512218\",\n \"0.55040383\",\n \"0.5503849\",\n \"0.55016327\",\n \"0.5496972\",\n \"0.5494969\",\n \"0.54913235\",\n \"0.54717356\",\n \"0.54710543\",\n \"0.54680324\",\n \"0.5463595\",\n \"0.54632014\",\n \"0.5456655\",\n \"0.5432586\",\n \"0.5431211\",\n \"0.5390512\",\n \"0.53814507\",\n \"0.53531635\",\n \"0.5348064\",\n \"0.5329896\",\n \"0.5327601\",\n \"0.5320248\",\n \"0.53028214\",\n \"0.52918303\",\n \"0.5291812\",\n \"0.5283449\",\n \"0.528083\",\n \"0.52756965\",\n \"0.52699065\",\n \"0.52694863\",\n \"0.5266493\",\n \"0.52603567\",\n \"0.52536565\",\n \"0.52522147\",\n \"0.5248579\",\n \"0.5248264\",\n \"0.52395904\",\n \"0.5236293\",\n \"0.5236293\",\n \"0.523429\",\n \"0.523282\",\n \"0.52271056\",\n \"0.5225341\",\n \"0.5224034\",\n \"0.52123666\",\n \"0.5210026\",\n \"0.51937366\",\n \"0.5192825\",\n \"0.51921606\",\n \"0.51917565\",\n \"0.5187125\",\n \"0.51834214\",\n \"0.51770663\",\n \"0.5160041\",\n \"0.51565856\",\n \"0.5155183\",\n \"0.51528865\",\n \"0.51519454\",\n \"0.5150073\",\n \"0.5144994\",\n \"0.51432085\",\n \"0.5140121\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.817184"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":909,"numItemsPerPage":100,"numTotalItems":95772,"offset":90900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTY3NjQzNSwianRpIjoiYTYwOTc0NzItNTFjZi00ZGJmLWFlNGEtNDlhYmRlOTQ4NDQwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2ODAwMzUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.EXpiJxAxeGTbF8hl48LlD37lYi3u8ja2Qs8IrId68ANLr2jMsC7jzWeVGiMIS5AaIfJvPMAoATiGK2UIicveAQ","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 |
|---|---|---|---|---|---|---|
Main entry point for module execution | def main():
required_if = [
("state", "merged", ("config",)),
("state", "replaced", ("config",)),
("state", "overridden", ("config",)),
("state", "rendered", ("config",)),
("state", "parsed", ("running_config",)),
]
mutually_exclusive = [("config", "running_config")... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n pass",
"def main():\n return",
"def main(self) -> None:\n pass",
"def main(self):\r\n pass",
"def main():\n module = IRODSPermissionModule()\n module.run()",
"def main():\n obj = UnityFilesystem()\n obj.perform_module_operation()",
"def run():\n main... | [
"0.7655644",
"0.7578341",
"0.7490611",
"0.7369463",
"0.7361173",
"0.7284486",
"0.72742957",
"0.7261932",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.72615725",
"0.... | 0.0 | -1 |
Return bounding box of biggest object of selected category. | def filter_inference_results(self, predictions, object_category='person'):
if predictions is not None and len(predictions) == 3:
bboxes, labels, confs = predictions
# Only return bounding boxes for the selected object category.
category_bboxes = [(bbox,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bounding_box(self):\n return None",
"def select_best_animal(found_animals: Dict[AnimalType, List[yolo.BoundBox]]) \\\n -> Tuple[AnimalType, yolo.BoundBox]:\n lb_size = 0.0\n largest_box = None\n lb_animal = \"\"\n for animal in found_animals.keys():\n ... | [
"0.6700369",
"0.66861564",
"0.65738463",
"0.65710014",
"0.65018713",
"0.6487645",
"0.64403796",
"0.64005184",
"0.63451606",
"0.63279337",
"0.6325666",
"0.62589586",
"0.6235425",
"0.6235425",
"0.62083435",
"0.61787564",
"0.61704993",
"0.61611485",
"0.615791",
"0.61494553",
"0.... | 0.6020185 | 38 |
Asynchronous update of detection results to return object center. | def update(self, predictions, frame, frameCenter):
if len(predictions) > 0:
(x, y, w, h) = predictions[0][0]
objectX = int(x + (w / 2.0))
objectY = int(y + (h / 2.0))
return ((objectX, objectY), predictions)
else:
return (frameCenter, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, frame, frameCenter):\n\t\t# GrayScale conversion from OpenCV\n\t\tgray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n\n\t\t# call the detector for the multiple faces from the input \n\t\trects = self.detector.detectMultiScale(gray, scaleFactor=1.05,\n\t\t\tminNeighbors=9, minSize=(30, 30),\n\t\t\tfla... | [
"0.57625234",
"0.5705489",
"0.5599008",
"0.5552633",
"0.5551374",
"0.55429983",
"0.55101174",
"0.5507732",
"0.5487247",
"0.54679406",
"0.5435144",
"0.5432267",
"0.5403248",
"0.53964525",
"0.53791773",
"0.5375063",
"0.5355548",
"0.53444505",
"0.532095",
"0.53023297",
"0.528739... | 0.5430607 | 12 |
call after request or when request failed | def teardown_request(exception):
if db.session is not None:
db.session.close()
else:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onfinish( request ):",
"def onfinish( request ):",
"def on_success(self) -> None:",
"def _handle_first_request(self):\n pass",
"def on_failure(self):\n pass",
"def _process_request(self, request, response):\n ...",
"def on_request_error(locust_instance, exception, tb, **kwargs)... | [
"0.7010329",
"0.7010329",
"0.6895634",
"0.6813143",
"0.68018883",
"0.6787187",
"0.6726384",
"0.6631935",
"0.6589202",
"0.64847404",
"0.64845294",
"0.64152426",
"0.6392727",
"0.6372866",
"0.63498706",
"0.63338596",
"0.63268614",
"0.6297562",
"0.6294351",
"0.6294351",
"0.626538... | 0.0 | -1 |
get today's date and show it | def get_today():
return dict(today = str(datetime.today())[:10]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_date_today() -> str:\n return datetime.now().strftime(\"%Y-%m-%d\")",
"def get_today_date():\n return date.today()",
"def get_current_date():\n return datetime.datetime.today().strftime(constants.DATE_FORMAT)",
"def todayDate(self):\n return time.strftime(\"%m/%d/%Y\", time.lo... | [
"0.8333997",
"0.81344694",
"0.810984",
"0.8056313",
"0.8011519",
"0.7931398",
"0.7928051",
"0.7920088",
"0.78313667",
"0.7784978",
"0.777743",
"0.7743336",
"0.76993936",
"0.7690719",
"0.7687875",
"0.7673903",
"0.76170886",
"0.753422",
"0.74367076",
"0.73783803",
"0.7342855",
... | 0.6360048 | 84 |
show all the entries in the index page | def show_entries():
books = Entries.query.order_by(Entries.title).all()
if 'adminname' in session and session['adminname'] is not None :
user = User.query.filter_by(username=session['adminname']).first()
books = map(encrypt_book_record, books)
return render_template('show_entries_admin.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list(request):\n return EntryView.__index(request)",
"def show_entries():\n db = get_db()\n cur = db.execute('select distinct name,repo_id,stars, description from python_repos order by stars desc')\n entries = cur.fetchall()\n # get api\n results = get_api()\n # The update operation ... | [
"0.75725347",
"0.7508032",
"0.73154354",
"0.73004013",
"0.7294184",
"0.72144544",
"0.72119045",
"0.7202788",
"0.71877694",
"0.7158893",
"0.7112895",
"0.711037",
"0.7086761",
"0.7053778",
"0.6993657",
"0.6922468",
"0.6921215",
"0.6899069",
"0.68835634",
"0.68834364",
"0.683068... | 0.0 | -1 |
show all the entries in the index page for administrators | def show_entries_admin():
books = map(encrypt_book_record, Entries.query.order_by(Entries.title).all())
if 'adminname' in session and session['adminname'] is not None :
user = User.query.filter_by(username=session['adminname']).first()
return render_template('show_entries_admin.html', books=book... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_all_information():\n if not g.user:\n flash(\"Please login to access\", \"danger\")\n return redirect(\"/\")\n if g.user.is_admin == False:\n flash (\"Unauthorized\", \"danger\")\n return redirect(\"/login\")\n\n employees = Employee.query.all()\n all_certs = employ... | [
"0.708475",
"0.69935346",
"0.69554603",
"0.68892956",
"0.68528265",
"0.6792956",
"0.6771388",
"0.6751204",
"0.6734227",
"0.6723165",
"0.668644",
"0.667853",
"0.65929514",
"0.6547838",
"0.6539842",
"0.6528335",
"0.64986575",
"0.64170974",
"0.63448447",
"0.6293383",
"0.62927675... | 0.74598587 | 0 |
add entry if admin is logged in | def add_entry():
if not check_admin_logged() :
abort(403)
title = request.form['title']
category = request.form['category']
buydate = request.form['buydate']
introduction = request.form['introduction']
if not check_items_in_form(title, category, buydate):
return redirect(url_fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _ad_add(self, ctx, member: discord.Member):\n new_admin = sql.TalosAdmin((ctx.guild.id, member.id))\n if new_admin not in self.database.get_admins(ctx.guild.id):\n self.database.save_item(new_admin)\n await ctx.send(f\"Added admin {member.name}!\")\n else:\n ... | [
"0.6794541",
"0.6406035",
"0.63694054",
"0.62817025",
"0.62354743",
"0.62257415",
"0.6197102",
"0.61642706",
"0.6162293",
"0.6114971",
"0.60939115",
"0.60805875",
"0.60700405",
"0.6014684",
"0.60051566",
"0.60028654",
"0.5984586",
"0.5975538",
"0.5967393",
"0.5945101",
"0.593... | 0.0 | -1 |
edit entry if admin is logged in | def edit_entry():
if not check_admin_logged() :
abort(403)
title = request.form['title']
category = request.form['category']
buydate = request.form['buydate']
ssid = decrypt_book_record(request.form['ssid'])
if not check_items_in_form(title, category, buydate):
return redirect(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home_edituser():\n\tpass",
"def edit(self):\n\n pass",
"def edit():",
"def show_entries_admin():\n books = map(encrypt_book_record, Entries.query.order_by(Entries.title).all())\n if 'adminname' in session and session['adminname'] is not None :\n user = User.query.filter_by(username=se... | [
"0.6982155",
"0.68434054",
"0.6830316",
"0.68228346",
"0.6598078",
"0.6589584",
"0.657738",
"0.6559947",
"0.6493951",
"0.64575356",
"0.64395964",
"0.63735574",
"0.63637996",
"0.6351722",
"0.6277955",
"0.6240855",
"0.62261134",
"0.62225854",
"0.62117785",
"0.6188642",
"0.61860... | 0.6233252 | 16 |
delete entry if admin is logged in | def delete_entry():
if not check_admin_logged() :
abort(403)
title = request.args.get('title', default='')
category = request.args.get('category', default='')
buydate = request.args.get('buydate', default='')
ssid = decrypt_book_record(request.args.get('ssid'))
pre_delete_entry = Entri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_entry():\n u_id = request.args(0) or redirect(URL('moderation', 'new_entries'))\n db(db.lioli_main.unique_id == u_id).delete()\n redirect(URL('new_entries'))\n return dict()",
"def on_model_delete(self, model):\n if not current_user.is_active or not current_user.is_authenticated:\n ... | [
"0.7008891",
"0.6864175",
"0.670782",
"0.66472805",
"0.66187227",
"0.66040117",
"0.6559425",
"0.6545127",
"0.6515902",
"0.6462635",
"0.63835216",
"0.63565546",
"0.63554716",
"0.63477015",
"0.63192195",
"0.6278768",
"0.6272764",
"0.62542844",
"0.6252763",
"0.62128603",
"0.6204... | 0.0 | -1 |
As this is a tiny private library system, it is not need to let strangers to log in or log up. So just add your friends in the app.config | def login():
error = None
form = Form()
# only support POST
if request.method == 'POST' :
username = request.form['username']
password = request.form['password']
# if the user is not an administrator
if username not in app.config['ADMINNAME'] :
# if the user ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gotConfig(self, mode, buddylist, permit, deny):\n global screename\n\n # add someone to our deny list?\n self.add_deny([])\n\n # add ourself to our buddy list\n self.add_buddy([screenname])\n\n # finish up the signon procedure\n self.signon()",
"def init_wecha... | [
"0.6370695",
"0.59829766",
"0.5262678",
"0.51919115",
"0.51740307",
"0.5138567",
"0.5136739",
"0.5124632",
"0.50850356",
"0.5025734",
"0.5023",
"0.49943757",
"0.4994048",
"0.49868828",
"0.4981748",
"0.49735132",
"0.49378282",
"0.49377882",
"0.49318695",
"0.49210507",
"0.49122... | 0.0 | -1 |
get the view of book according to the title. title [string] the title of the relative book | def get_book_view(title):
# 使用来自数据库的数据来动态生成页面而不是映射到对应的静态页面上去
# 目前对于这个小应用还可以，在将来可能需要修改
if not check_title_is_existed(title) :
return redirect(url_for('show_entries'))
category = request.args.get('category', default='')
buydate = request.args.get('buydate', default='')
selected_entry = E... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, book_title):\n return qh.get_book_title(book_title)",
"def getBook(self, title):\n return self._books.get(title, None)",
"def book(title):\n\n # Make sure user is logged in\n if \"username\" not in session:\n return render_template(\"index.html\", message=\"Please login... | [
"0.70195967",
"0.6880717",
"0.6197569",
"0.5954362",
"0.5864457",
"0.58029574",
"0.5758659",
"0.5707605",
"0.5605071",
"0.5558975",
"0.5505221",
"0.55045694",
"0.55041933",
"0.5483169",
"0.5453215",
"0.5435752",
"0.5412766",
"0.5356288",
"0.5307087",
"0.52594316",
"0.525346",... | 0.7128281 | 0 |
the view of borrow page. Users can fill the form of borrowing and submit it to the administrators. Then the administrator will be noticed to handle it. username [sting] the username of User | def borrow(user_id):
user = User.query.filter_by(user_id=user_id).first_or_404()
# make sure the user who will fill the form is the user
# whose user_id is reponsitive to the URL
if user.username == session.get('username') or \
user.username == session.get('adminname') :
book_ids = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_buss(request):\n current_user = request.user\n \n return render(request,'main_templates/view_buss.html')",
"def renewborrower():\n if not g.userInfo:\n return redirect(url_for('base_page.index', user=None))\n error = None\n if request.method == 'POST':\n if g.userInfo[8] ... | [
"0.66166013",
"0.62493306",
"0.6241006",
"0.61999243",
"0.6088848",
"0.60641193",
"0.5907898",
"0.5905894",
"0.5887535",
"0.58647573",
"0.58345824",
"0.583217",
"0.5806807",
"0.5792316",
"0.5774784",
"0.57665324",
"0.57563657",
"0.5755857",
"0.5753773",
"0.5753773",
"0.574071... | 0.7075745 | 0 |
the view of reborrow page. Users can fill the form of reborrowing and submit it to the administrators. Then the administrator will be noticed to handle it. username [sting] the username of User | def reborrow(user_id):
user = User.query.filter_by(user_id=user_id).first_or_404()
# make sure the user who will fill the form is the user
# whose user_id is reponsitive to the URL
if user.username == session.get('username') or \
user.username == session.get('adminname') :
book_ids ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def renewborrower():\n if not g.userInfo:\n return redirect(url_for('base_page.index', user=None))\n error = None\n if request.method == 'POST':\n if g.userInfo[8] in ['clerk']:\n bid = request.form['bid'].encode('utf-8')\n match = TableOperation.sfw('Borrower', ['*'], ... | [
"0.67607075",
"0.608056",
"0.60169417",
"0.59693",
"0.5887694",
"0.5813947",
"0.57972085",
"0.5781515",
"0.5766197",
"0.57499635",
"0.5727291",
"0.57140523",
"0.5690077",
"0.56435955",
"0.563414",
"0.5603867",
"0.5584838",
"0.5575254",
"0.55746365",
"0.5572139",
"0.5563708",
... | 0.66658294 | 1 |
the view of return page. Users can fill the form of return book and submit it to the administrators. Then the administrator will be noticed to handle it. username [sting] the username of User | def return_book(user_id):
user = User.query.filter_by(user_id=user_id).first_or_404()
# make sure the user who will fill the form is the user
# whose user_id is reponsitive to the URL
if user.username == session.get('username') or \
user.username == session.get('adminname') :
book_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_main_page():\n username = sign_up.get_username()\n if username:\n main_var = dict(user = username, stat_rows = STATS, location = LOCATION)\n return bottle.template('main', main_var = main_var)\n else:\n bottle.redirect('/login')",
"def index():\n if request.method == \"P... | [
"0.652459",
"0.64362925",
"0.63072705",
"0.62538195",
"0.6228235",
"0.6204274",
"0.62004447",
"0.6089296",
"0.6054652",
"0.6028118",
"0.59808975",
"0.59808975",
"0.59639364",
"0.58927494",
"0.58544517",
"0.584234",
"0.5839047",
"0.5837261",
"0.582492",
"0.5820283",
"0.5818793... | 0.54864395 | 81 |
Return True if session is localized. | def db_session_is_localized(self):
return self.__dict__.has_key('db_session') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ctx_has_locale() -> bool:\n ctx = _get_current_context()\n if ctx is None:\n return False\n return hasattr(ctx, 'babel_locale')",
"def IsLoaded(*args, **kwargs):\n return _gdi_.Locale_IsLoaded(*args, **kwargs)",
"def getIsMultilingual(self):\n return self.getOrDefault(self.isM... | [
"0.650045",
"0.61962056",
"0.611111",
"0.6054472",
"0.5953662",
"0.5830956",
"0.58225954",
"0.5765789",
"0.5690028",
"0.56166595",
"0.55772704",
"0.5532859",
"0.5453551",
"0.54300606",
"0.54264396",
"0.5391326",
"0.53821754",
"0.53780025",
"0.53728426",
"0.5369159",
"0.535767... | 0.80610275 | 0 |
Open a new SQLAlchemy session. This new session is assigned to L{db_session} of this widget and all descendant widgets until either L{db_session_commit_and_globalize} or L{db_session_rollback_and_globalize} is called on this widget. | def db_session_localize(self):
if self.db_session:
engine = self.db_session.bind
else:
engine = self.session.program.DBModel.engine
self.db_session = engine.Session()
# Keep track of session
self.session.worm_localized.add(self.db_session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open(self):\n self._session = self.session_open()",
"def _set_session(self):\n self.__session = sessionmaker(bind=self.__engine)()",
"def open_session(self):\n return self.Session()",
"def db_session(request, config):\n from h import db\n engine = db.make_engine(config.registry... | [
"0.6899055",
"0.68543345",
"0.65129745",
"0.64536434",
"0.63311404",
"0.6317526",
"0.62793005",
"0.6276834",
"0.6266114",
"0.62572324",
"0.62396383",
"0.6225321",
"0.6216103",
"0.6184517",
"0.61438495",
"0.6094303",
"0.60222036",
"0.6020307",
"0.6011334",
"0.5982175",
"0.5963... | 0.64901483 | 3 |
Commit the current local SQLAlchemy session (created with L{db_session_localize} on this widget) and remove/close the session, making the global session visible to this widget and descendant widgets again. You might want to do self.db_session.expire() after this to make any changes to your local session visible in the ... | def db_session_commit_and_globalize(self):
self.db_session.commit()
self.session.worm_localized.remove(self.db_session)
del self.db_session
# FIXME: Update all nested localized sessions.
self.db_session.expire_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_session_rollback_and_globalize(self):\n self.db_session.rollback()\n self.session.worm_localized.remove(self.db_session)\n del self.db_session",
"def save_before_close(self):\n if self.db_window:\n self.db_window.destroy()\n self.destroy()",
"def commit(self... | [
"0.67239785",
"0.66214174",
"0.64808667",
"0.64619935",
"0.63480055",
"0.6337384",
"0.6296969",
"0.6253922",
"0.6190622",
"0.612898",
"0.6086176",
"0.6084393",
"0.6043479",
"0.598818",
"0.59869117",
"0.5958185",
"0.59485453",
"0.5934197",
"0.5917074",
"0.5917074",
"0.5917074"... | 0.78256214 | 0 |
Rollback the current local SQLAlchemy session (created with L{db_session_localize} on this widget) and remove/close the session, making the global session visible to this widget and descendant widgets again. | def db_session_rollback_and_globalize(self):
self.db_session.rollback()
self.session.worm_localized.remove(self.db_session)
del self.db_session | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_session_commit_and_globalize(self):\n self.db_session.commit()\n self.session.worm_localized.remove(self.db_session)\n del self.db_session\n # FIXME: Update all nested localized sessions.\n self.db_session.expire_all()",
"def _close(self):\n if self.__session is n... | [
"0.69830817",
"0.6831465",
"0.6580956",
"0.63987786",
"0.63065374",
"0.6255354",
"0.6255354",
"0.6255354",
"0.62003577",
"0.619857",
"0.61350036",
"0.60096955",
"0.6001342",
"0.5989135",
"0.59747803",
"0.59709346",
"0.59528714",
"0.5927543",
"0.5882605",
"0.58783174",
"0.5874... | 0.78382546 | 0 |
Rollbacks the current (local) SQLAlchemy session and appends the current exception and backtrace to the list of error messages for this widget. | def append_exception(self, message=u''):
if isinstance(sys.exc_info()[1], sqlalchemy.exceptions.SQLAlchemyError):
self.db_session.rollback()
Webwidgets.Widget.append_exception(self, message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rollback(self):\n raise TransactionRollback('rollback called outside of transaction')",
"def rollback(self):\n\n if not self.is_active:\n return\n\n if self.is_context_active:\n raise states.RolledBack(self)\n else:\n self.__do_rollback()\n ... | [
"0.68692607",
"0.68417865",
"0.6727358",
"0.6682666",
"0.66604054",
"0.66078806",
"0.6595147",
"0.6576987",
"0.65565866",
"0.6475917",
"0.63871044",
"0.62523556",
"0.62087405",
"0.61652637",
"0.61646914",
"0.6125406",
"0.6104549",
"0.61016774",
"0.6100832",
"0.6083901",
"0.60... | 0.72351116 | 0 |
Sync to_directory with from_directory by copying each file in to_directory with new contents. Files in to_directory will be overwritten by files of the same name in from_directory. We need to keep two copies of the log directory because otherwise TensorBoard picks up temp files from `aws s3 sync` and then stops reading... | def _sync_directories(from_directory, to_directory):
if not os.path.exists(to_directory):
os.mkdir(to_directory)
for root, dirs, files in os.walk(from_directory):
to_root = root.replace(from_directory, to_directory)
for directory in dirs:
to_child_dir ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _copy_metadata(from_dir, to_dir):\n if not FLAGS.dry_run:\n tf.io.gfile.makedirs(to_dir)\n for fname in tfds.core.utils.list_info_files(from_dir):\n from_path = os.path.join(from_dir, fname)\n to_path = os.path.join(to_dir, fname)\n logging.info('cp %s %s', from_path, to_path)\n if not FLAGS.d... | [
"0.6270665",
"0.60585004",
"0.5803349",
"0.5785908",
"0.57809067",
"0.57445365",
"0.5681512",
"0.563036",
"0.5578538",
"0.557493",
"0.5568786",
"0.5554208",
"0.5548205",
"0.55205566",
"0.54880303",
"0.54073787",
"0.53864986",
"0.53833014",
"0.5359479",
"0.53504395",
"0.535022... | 0.78838134 | 0 |
Context manager for a temporary directory. This is similar to tempfile.TemporaryDirectory in python>=3.2. | def _temporary_directory():
name = tempfile.mkdtemp()
try:
yield name
finally:
shutil.rmtree(name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def use_temp_dir():\n directory = tempfile.mkdtemp()\n try:\n yield directory\n finally:\n shutil.rmtree(directory)",
"def tempdir():\n\n class ctx(object):\n\n def __enter__(self):\n self.prevdir = os.getcwd()\n self.tempdir = tempfile.mkdtemp()\n ... | [
"0.8151143",
"0.80606616",
"0.79753256",
"0.79536724",
"0.79371685",
"0.79356587",
"0.79355663",
"0.7912876",
"0.78649515",
"0.78183824",
"0.7785393",
"0.7777123",
"0.77747816",
"0.7705706",
"0.7695398",
"0.7673213",
"0.7660842",
"0.76580966",
"0.7650998",
"0.7628625",
"0.761... | 0.8148666 | 1 |
Ensure that TensorBoard and the AWS CLI are installed. These dependencies are required for using TensorBoard. | def validate_requirements(self):
if not self._cmd_exists('tensorboard'):
raise EnvironmentError(
'TensorBoard is not installed in the system. Please install TensorBoard using the'
' following command: \n pip install tensorboard')
if not self._cmd_exists('aws'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bootstrap_aws():\n sub_install_packages()\n sub_install_virtualenv()\n sub_create_virtualenv()\n sub_install_python_requirements_aws()",
"def install_sm_local_dependencies(framework, job_type, image, ec2_conn, ec2_instance_ami):\n python_invoker = get_python_invoker(ec2_instance_ami)\n # In... | [
"0.577606",
"0.557087",
"0.55209863",
"0.5308761",
"0.51443",
"0.5119925",
"0.50857913",
"0.50799906",
"0.50063074",
"0.49969366",
"0.49491173",
"0.4945465",
"0.4945246",
"0.4934019",
"0.489118",
"0.48885366",
"0.48777446",
"0.48691902",
"0.4865129",
"0.48568448",
"0.4839932"... | 0.7782969 | 0 |
Create a TensorBoard process. | def create_tensorboard_process(self):
port = 6006
for _ in range(100):
p = subprocess.Popen(
["tensorboard", "--logdir", self.logdir, "--host", "localhost", "--port",
str(port)],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_tensorboard(self):\n python_path = sys.executable\n option = '--logdir=' + self.instance.instance_summary_folder_path\n args_ = [python_path, tensorboard_dir(), option]\n self.open_subprocess(args_=args_, subprocess_key=\"tensorboard\")",
"def create_new_board():\n\n board... | [
"0.5967794",
"0.5926481",
"0.59220135",
"0.5821974",
"0.581349",
"0.5765901",
"0.57170624",
"0.56288046",
"0.5552559",
"0.5532915",
"0.5530233",
"0.55097836",
"0.5477901",
"0.54768014",
"0.5469086",
"0.541693",
"0.5408603",
"0.5384963",
"0.53506166",
"0.5337728",
"0.5313522",... | 0.69384116 | 0 |
Initialize a ``TensorFlow`` estimator. | def __init__(self, training_steps=None, evaluation_steps=None, checkpoint_path=None, py_version='py2',
framework_version=None, model_dir=None, requirements_file='', image_name=None,
script_mode=False, distributions=None, **kwargs):
if framework_version is None:
LOGG... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_tf_estimator(desc_file, model_dir):\n sess_config = tf.compat.v1.ConfigProto()\n sess_config.gpu_options.allow_growth = True\n config = tf.estimator.RunConfig(\n model_dir=model_dir, session_config=sess_config)\n model = ModelZoo().get_model(desc_file)\n\n def _model_fn(features, la... | [
"0.6552767",
"0.6466512",
"0.6449601",
"0.6394394",
"0.6393175",
"0.63629436",
"0.6302219",
"0.62377006",
"0.62219465",
"0.62131083",
"0.62071836",
"0.61888766",
"0.61823803",
"0.615833",
"0.6128869",
"0.6120501",
"0.60965437",
"0.6055643",
"0.60521173",
"0.60483944",
"0.6043... | 0.6599906 | 0 |
Train a model using the input training dataset. | def fit(self, inputs=None, wait=True, logs=True, job_name=None, run_tensorboard_locally=False):
def fit_super():
super(TensorFlow, self).fit(inputs, wait, logs, job_name)
if run_tensorboard_locally and wait is False:
raise ValueError("Tensorboard is not supported with async fit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)",
"def train(self, dataset, model_dir):\n raise NotImplementedError",
"def train_model(dataset):\n\n # clear the session so that we can train more than one model\n K.clear_session()\n\n # initialize the model\n mo... | [
"0.8336931",
"0.8285992",
"0.8002057",
"0.7980904",
"0.7916354",
"0.78606725",
"0.77298415",
"0.76773417",
"0.7635647",
"0.75519866",
"0.754373",
"0.7486066",
"0.74526685",
"0.7441079",
"0.7425182",
"0.7388736",
"0.73418176",
"0.73383117",
"0.7329356",
"0.73053706",
"0.727627... | 0.0 | -1 |
Convert the job description to init params that can be handled by the class constructor | def _prepare_init_params_from_job_description(cls, job_details, model_channel_name=None):
init_params = super(TensorFlow, cls)._prepare_init_params_from_job_description(job_details,
model_channel_name)
# Move some of... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, name, job):\n self.name = name\n self.job = job\n self.runspecs = []",
"def __init__(self, jobArgs):\n logging.info(\"Constructing job with args %r\" % jobArgs)\n self.args = jobArgs\n\n self._setup()",
"def __init__(self, job: str=None): #... | [
"0.6796401",
"0.67320555",
"0.6613759",
"0.64385927",
"0.6432858",
"0.64260584",
"0.64236677",
"0.64035034",
"0.6401971",
"0.63969374",
"0.6380496",
"0.6379365",
"0.63259536",
"0.62696606",
"0.6234088",
"0.62133336",
"0.62065643",
"0.61886764",
"0.61812884",
"0.61811143",
"0.... | 0.6507478 | 3 |
Create a SageMaker ``TensorFlowModel`` object that can be deployed to an ``Endpoint``. | def create_model(self, model_server_workers=None, role=None,
vpc_config_override=VPC_CONFIG_DEFAULT, endpoint_type=None):
role = role or self.role
if endpoint_type == 'tensorflow-serving' or self._script_mode_enabled():
return self._create_tfs_model(role=role, vpc_confi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self) -> tf.keras.models.Model:\n raise NotImplementedError()",
"def _make_model(self):\n self._model = tf.estimator.Estimator(model_fn=self.model_fn,\n model_dir=self.model_dir,\n config=self._config... | [
"0.6819635",
"0.65104693",
"0.6498425",
"0.64926046",
"0.64838105",
"0.6425016",
"0.63994265",
"0.63273954",
"0.63156533",
"0.6306389",
"0.61792016",
"0.6173705",
"0.6173564",
"0.61605144",
"0.6146582",
"0.6115818",
"0.607953",
"0.6077646",
"0.60186505",
"0.6012362",
"0.59610... | 0.7037425 | 0 |
Return hyperparameters used by your custom TensorFlow code during model training. | def hyperparameters(self):
hyperparameters = super(TensorFlow, self).hyperparameters()
self.checkpoint_path = self.checkpoint_path or self._default_s3_path('checkpoints')
mpi_enabled = False
if self._script_mode_enabled():
additional_hyperparameters = {}
if 'pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hyper_params():\n #################################\n ##### INSERT YOUR CODE HERE #####\n layers_size = [4096, 4096, 10]\n activation = 'relu'\n lr = 0.3\n epochs = 30\n dropout_rate = 0.2\n init_kind = 'xavier'\n ##### END YOUR CODE HERE ########\n ###########################... | [
"0.70930415",
"0.7077545",
"0.7065782",
"0.7065782",
"0.7055262",
"0.7031362",
"0.677347",
"0.65879756",
"0.6468851",
"0.6413826",
"0.64121133",
"0.6412008",
"0.6360292",
"0.6342025",
"0.6325073",
"0.62614775",
"0.6248047",
"0.6244461",
"0.62323964",
"0.6215574",
"0.62067944"... | 0.70037484 | 6 |
Returns True if row and col are valid values | def valid_input(self, row, col):
return ((row, col) not in self.marks and
row <= WIDTH and row > 0 and
col in COL_MAP) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid(self,row,col) -> bool:\n if(row >=0 and col>=0 and row<self.row and col<self.col and self.array[row][col]==-1 ):\n return True\n return False",
"def is_valid(self):\n if self.get_row() != -1 and self.get_column() != -1:\n return True\n else:\n ... | [
"0.8091675",
"0.80864257",
"0.7924023",
"0.78902096",
"0.7659951",
"0.75877786",
"0.7548906",
"0.75047547",
"0.7499336",
"0.74562085",
"0.74394834",
"0.7436682",
"0.7368682",
"0.7337169",
"0.73290545",
"0.73265445",
"0.7304924",
"0.7300693",
"0.7293138",
"0.7280832",
"0.72412... | 0.8213445 | 0 |
Place a piece on the board at position ROWCOL raises a ValueError if row or column is invalid | def mark(self, row, col, piece):
if self.valid_input(row, col):
self.marks.add((row, col))
self.place_at(row - 1, COL_MAP[col], piece)
else:
raise ValueError("invalid row and column supplied: row={}, col={}"
.format(row, col)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def place_at(self, row, col, piece):\n self.board[row + PADDING][col + PADDING] = piece",
"def place_piece(piece, px, py, pc):\n \n\n for i, j in piece:\n x = px + i\n y = py + j\n if not (0 <= x < BOARD_WIDTH):\n continue\n if not (0 <= y < BOARD_HEIGHT):\n ... | [
"0.8029984",
"0.7447671",
"0.7363715",
"0.709779",
"0.7061457",
"0.6989181",
"0.69663006",
"0.69336915",
"0.6894504",
"0.68795395",
"0.6845852",
"0.6845852",
"0.6838324",
"0.6800873",
"0.6779366",
"0.66910005",
"0.66720957",
"0.66690725",
"0.66428804",
"0.6642121",
"0.6630201... | 0.71148443 | 3 |
Get the piece at the zero indexed row and column | def piece_at(self, row, col):
return self.board[row + PADDING][col + PADDING] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_piece(self, row, column):\n return self._board[row][column]",
"def __getitem__(self, index):\n x, y = index\n if 0 <= x < self.width and 0 <= y < self.height:\n return self.cells[x + y * self.width]\n else:\n return None",
"def get(self,row,col):\r\n ... | [
"0.7295416",
"0.7274309",
"0.7000315",
"0.6965118",
"0.6947245",
"0.6947245",
"0.693291",
"0.6913047",
"0.68802345",
"0.68495584",
"0.6844074",
"0.67958635",
"0.67958635",
"0.67958635",
"0.67885065",
"0.6768237",
"0.67560166",
"0.67495924",
"0.6747535",
"0.67233706",
"0.67163... | 0.7676288 | 0 |
Place the piece at the zero indexed row and column | def place_at(self, row, col, piece):
self.board[row + PADDING][col + PADDING] = piece | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def place_piece(piece, px, py, pc):\n \n\n for i, j in piece:\n x = px + i\n y = py + j\n if not (0 <= x < BOARD_WIDTH):\n continue\n if not (0 <= y < BOARD_HEIGHT):\n continue\n board[y][x] = pc",
"def put_piece(self, piece, row, col):\n self... | [
"0.661512",
"0.64310443",
"0.6252745",
"0.6204028",
"0.61396724",
"0.61396724",
"0.6106943",
"0.60911864",
"0.6088476",
"0.60754514",
"0.60331696",
"0.59899485",
"0.5988769",
"0.5980728",
"0.59770834",
"0.59721535",
"0.59702325",
"0.5960619",
"0.5960619",
"0.5957366",
"0.5940... | 0.7319728 | 0 |
Check if the last mark added at (r,c) creates a winning state | def has_win(self, r, c, mark):
row = r - 1
col = COL_MAP[c]
cnt = 0
board_range = xrange(-1 * PADDING, PADDING + 1)
# check vertical
for dr in board_range:
cnt = cnt + 1 if self.piece_at(row + dr, col) == mark else cnt
if cnt == WIDTH:
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_win():\r\n for mark in markers:\r\n if loc[0] == mark and loc[1] == mark and loc[2] == mark:\r\n return True\r\n if loc[0] == mark and loc[3] == mark and loc[6] == mark:\r\n return True\r\n if loc[0] == mark and loc[4] == mark and loc[8] == mark:\r\n ... | [
"0.70109254",
"0.6833651",
"0.66280854",
"0.6573794",
"0.6418051",
"0.6405248",
"0.64018345",
"0.6397932",
"0.63818234",
"0.63676876",
"0.6360904",
"0.63500106",
"0.63415575",
"0.6315963",
"0.63062656",
"0.62958235",
"0.62924767",
"0.62854916",
"0.6272178",
"0.62693036",
"0.6... | 0.6819999 | 2 |
Returns true if a tie exists on this board | def tie_exists(self):
return len(self.marks) == 9 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_tie(board):\n return 0 not in board[0]",
"def game_tie(self):\n\n shape = self.board.shape\n if np.count_nonzero(self.board) == (shape[0] * shape[1]):\n # The board is full\n player = 0\n return True\n else:\n return False",
"def _is... | [
"0.7543741",
"0.74421966",
"0.7174385",
"0.7158319",
"0.70751244",
"0.6951705",
"0.6935137",
"0.6933638",
"0.68399227",
"0.6839235",
"0.67778605",
"0.66985226",
"0.6692007",
"0.6671597",
"0.6668072",
"0.66296566",
"0.6591076",
"0.655537",
"0.65299284",
"0.6523104",
"0.6508229... | 0.75141263 | 1 |
At version 4, L{PrivateApplication} should be an L{ITemplateNameResolver} powerup on its store. | def test_powerup(self):
application = self.subStore.findUnique(PrivateApplication)
powerups = list(self.subStore.powerupsFor(ITemplateNameResolver))
self.assertIn(application, powerups) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unknown_app(self):\n self.make_unknown()",
"def test_unshare_template_registration(self):\n pass",
"def test_share_template_registration(self):\n pass",
"def test_default_app_exclusion(self):\n mock_apps = Apps(collections.OrderedDict([\n ('project', AppConfig('/tm... | [
"0.60529256",
"0.55721647",
"0.55654305",
"0.5417136",
"0.52996993",
"0.52925515",
"0.5281819",
"0.524015",
"0.5176775",
"0.5120206",
"0.5104463",
"0.5077667",
"0.507308",
"0.50712687",
"0.50686026",
"0.50586444",
"0.50278133",
"0.5021658",
"0.5019095",
"0.5005884",
"0.498781... | 0.66232014 | 0 |
At version 5, L{PrivateApplication} should be an L{IWebViewer} powerup on its store. | def test_webViewer(self):
application = self.subStore.findUnique(PrivateApplication)
interfaces = list(self.subStore.interfacesFor(application))
self.assertIn(IWebViewer, interfaces) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsApplicationTrustedToRun(self) -> bool:",
"def hide_web(self) -> bool:\n return pulumi.get(self, \"hide_web\")",
"def is_web_exhibit(self):\n return self.web_exhibit",
"def getApp(self):\n raise Exception('Not implemented.')",
"def hide_web(self) -> Optional[pulumi.Input[bool]]:\n ... | [
"0.60877794",
"0.60449106",
"0.5861428",
"0.58399016",
"0.5555351",
"0.5555351",
"0.5517078",
"0.55023813",
"0.55023813",
"0.5469189",
"0.5369433",
"0.52974826",
"0.5247031",
"0.52344793",
"0.5140546",
"0.51220024",
"0.5096964",
"0.5088554",
"0.5088383",
"0.50786066",
"0.5077... | 0.74925315 | 0 |
All of the attributes of L{PrivateApplication} should have the same values on the upgraded item as they did before the upgrade. | def test_attributes(self):
application = self.subStore.findUnique(PrivateApplication)
self.assertEqual(application.preferredTheme, PREFERRED_THEME)
self.assertEqual(application.privateKey, PRIVATE_KEY)
website = self.subStore.findUnique(WebSite)
self.assertIdentical(application.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allow_version_invalid_attributes(self):\n return self._allow_version_invalid_attributes",
"def test_back_compat_attributes(self):\n #Populate all fields from older version\n att = AttestationMechanism.create_with_tpm(DUMMY_EK, DUMMY_SRK)\n\n #Check back compat\n self.assert... | [
"0.6245698",
"0.5929279",
"0.5904795",
"0.58279717",
"0.55963385",
"0.5523848",
"0.54675084",
"0.54672045",
"0.54174125",
"0.54007536",
"0.5341977",
"0.528145",
"0.5236794",
"0.51826143",
"0.5157563",
"0.5117754",
"0.5107747",
"0.510474",
"0.5098657",
"0.50835973",
"0.5053894... | 0.6672605 | 0 |
invoke local "sendmail" program to send a message. `from_addr' is envelope sender string (may be empty) `to_addrs' is list of envelope recipient addresses string will be treated as a list with 1 address. `msg' is headers and body of message to be sent `mail_options' is iterable of options ('8bitmime') | def sendmail(self, from_addr, to_addrs, msg, mail_options=()):
# -i flag: do NOT treat bare dot as EOF
cmd = [self.SENDMAIL, '-i']
if from_addr: # envelope sender?
cmd.append('-f%s' % from_addr)
if isinstance(to_addrs, tuple): # be liberal
to_addrs = li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email(self, fromaddr, addrs, message=\"\"):\n smtp = smtplib.SMTP(self._server, self._port)\n smtp.sendmail(fromaddr, addrs, message)\n smtp.quit()",
"def send(self, to_addrs, subject, message, from_addr=None):\n if not from_addr: from_addr = self.user\n data = \"From:... | [
"0.6988561",
"0.68563634",
"0.6601052",
"0.6585389",
"0.64585745",
"0.63953036",
"0.6283752",
"0.61753005",
"0.61150044",
"0.6057249",
"0.60445815",
"0.5993516",
"0.5962057",
"0.59512377",
"0.58791",
"0.5838177",
"0.5820097",
"0.57974416",
"0.5784525",
"0.5771491",
"0.5750710... | 0.82503575 | 0 |
Returns data for given view. | def get(view):
vid = view.id()
if vid not in __view_data:
__view_data[vid] = ViewData()
return __view_data[vid] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_data_from_view(self):\n self.log.info(\"Getting data from view: vw_AllSurveyData \")\n view_data = self.db.execute_pandas_query(self._get_query('vw_survey_data'))\n self._export_data_to_csv(view_data, 'fresh_survey_data.csv')",
"def data():\n return app_views",
"def get(self):\... | [
"0.69719744",
"0.65511465",
"0.6454514",
"0.6106453",
"0.60731554",
"0.6032415",
"0.6002862",
"0.5964178",
"0.5920505",
"0.59087116",
"0.5887843",
"0.5873122",
"0.5873122",
"0.58712596",
"0.58350617",
"0.57830334",
"0.57830334",
"0.57830334",
"0.57790315",
"0.5770231",
"0.572... | 0.8006146 | 0 |
Clears data for given view. | def clear(view):
vid = view.id()
if vid in __view_data:
del __view_data[vid] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\n for key in self.__data.keys():\n del self.__data[key]",
"def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_rerun()",
"def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_re... | [
"0.62898004",
"0.62870723",
"0.62870723",
"0.62837917",
"0.62837917",
"0.62837917",
"0.62777203",
"0.62517434",
"0.6241923",
"0.62245846",
"0.6216914",
"0.61368096",
"0.60570216",
"0.59968454",
"0.59798944",
"0.59653443",
"0.5953536",
"0.5953536",
"0.59517497",
"0.5935838",
"... | 0.8280418 | 0 |
Returns the appropriate options for positioning the editor at the end of the file. This function attempts to parse the random weird values people set EDITOR to, including bare commands, commands with arguments, and commands with paths. | def at_end_options(editor):
# Trim off any trailing command-line arguments
editor = editor.split()[0]
path, binary = os.path.split(editor)
return AT_END.get(binary, []) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVKBEditMode(self):\r\n return eval(self.phone.sx('(send (get-text-editor-manager) get-edit-mode)', convertToString=True).title())",
"def parameter_tweaks( cls, ):\n cls.file_text_editor.add_command( cls.parameters.ex_editor )\n print( f\"parameter tweaks {cls.text_editors}\" ) #",
... | [
"0.5471067",
"0.5408208",
"0.5314189",
"0.52699107",
"0.52628803",
"0.5101266",
"0.5094795",
"0.50926393",
"0.50667274",
"0.50158817",
"0.49822855",
"0.49191922",
"0.48989746",
"0.4889055",
"0.48730737",
"0.48699728",
"0.4853894",
"0.48388448",
"0.4837549",
"0.48262706",
"0.4... | 0.6475677 | 0 |
a) create a list of the dict's keys and values; b) return the key with the max value | def keywithmaxval(d):
v=list(d.values())
k=list(d.keys())
return k[v.index(max(v))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keywithmaxval(dictionary): # from https://stackoverflow.com/questions/268272/getting-key-with-maximum-value-in-dictionary/12343826#12343826 \n\tv=list(dictionary.values())\n\tk=list(dictionary.keys())\n\treturn k[v.index(max(v))]",
"def keywithmaxval(d): \r\n v=list(d.values())\r\n k=list(d.keys())\r... | [
"0.853163",
"0.8514927",
"0.8256926",
"0.8177595",
"0.8094488",
"0.79967916",
"0.7868477",
"0.78300834",
"0.7704722",
"0.76255924",
"0.7562913",
"0.75439674",
"0.7499252",
"0.73198014",
"0.7308097",
"0.72959465",
"0.72901344",
"0.7287315",
"0.72506607",
"0.71176517",
"0.70939... | 0.8609644 | 1 |
This Method removes a user from users dictonary using his/her unique email | def remove_user(self, email):
try:
self.users.pop(email)
except KeyError:
raise UserDoesNotExist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_user_by_email(tx: Transaction, user_email: str) -> BoltStatementResult:\n query = f\"\"\"\n MATCH(n: Person {{email: '{user_email}'}})\n OPTIONAL MATCH(n)--(p: Post)\n DETACH DELETE n, p\"\"\"\n return tx.run(query)",
"def delete_user():",
"def remove_user(self, email):\n retur... | [
"0.69708824",
"0.6968639",
"0.6901791",
"0.68791765",
"0.676308",
"0.6720373",
"0.67113143",
"0.6665886",
"0.6653795",
"0.6613853",
"0.6590403",
"0.65338796",
"0.65085775",
"0.64608604",
"0.6459394",
"0.645211",
"0.6443287",
"0.6443287",
"0.6443287",
"0.6426062",
"0.63953745"... | 0.7922419 | 0 |
Pull features from a Django queryset into a Mapnik MemoryDatasource. | def get_mapnik_ds(self,**kwargs):
if not self.geometry_field:
raise ValueError('Geometry field not found')
import itertools
ids = itertools.count(0)
assert hasattr(mapnik,'MemoryDatasource'), "mapnik.MemoryDatasource requires >= mapnik 2.1"
ds = mapnik.MemoryDatasour... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_sources(self, obj):\n page = self.context['request'].GET.get('page', 1)\n per_page = settings.PAGINATE_VIEW_FEATURE\n if self.context.get('include_child_pages'):\n # Paginate the full descendant tree\n child_queryset = self.get_all_descendants(obj, per_page)\n ... | [
"0.5736881",
"0.5424447",
"0.5375144",
"0.53365606",
"0.52723587",
"0.5213967",
"0.5206796",
"0.5202837",
"0.5145447",
"0.51072246",
"0.5096067",
"0.50892884",
"0.50744784",
"0.5070945",
"0.50434893",
"0.5042958",
"0.5004544",
"0.49874857",
"0.49811295",
"0.4974702",
"0.49594... | 0.70629114 | 0 |
Transform the raw SQL from a Django queryset into a Mapnik subquery. | def _as_mapnik_sql(self,**kwargs):
# running multidb available in django 1.2
if hasattr(self.qs.query,'get_compiler'):
compiler = self.qs.query.get_compiler(self.qs.db)
sql, args = compiler.as_sql()
gqn = compiler.connection.ops.geo_quote_name
else:
sq... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_qs_from_raw_sql(self, request, search_term):\n parent_id = request.GET.get('parent_id', False)\n\n ocr_lang = request.user.preferences['ocr__OCR_Language']\n ocr_lang = ocr_lang.lower()\n\n sql = \"\"\n\n if parent_id:\n descendent_ids = [\n str(... | [
"0.5818013",
"0.5739249",
"0.5636696",
"0.558741",
"0.5584599",
"0.55839396",
"0.5517639",
"0.54935175",
"0.5489652",
"0.5447503",
"0.5412583",
"0.54007304",
"0.5360466",
"0.535188",
"0.53101003",
"0.5300829",
"0.52986085",
"0.5288278",
"0.5281991",
"0.52807224",
"0.5270242",... | 0.67043734 | 0 |
Groupwise groupwise resnik similarity assumes no negative phenotypes | def groupwise_sim_gic(
self,
profiles: Iterable[Iterable[str]],
predicate: Optional[URIRef] = RDFS['subClassOf']) -> float:
# Filter out negative phenotypes
profile_union = set()
profile_intersection = set()
is_first = True
for profile in prof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def similarity_search(self):\n self.ssr = {gene: self.ssw.get_phenotypically_similar_genes(phenotypes, taxon=self.taxon) for gene, phenotypes in self.gene2phenotype_associations.items()}\n self.results = [ssr.get_results() for ssr in self.ssr.values()]\n self.phenogene_score = reduce(lambda x,... | [
"0.6073969",
"0.5990463",
"0.58325976",
"0.5827893",
"0.58159024",
"0.57934237",
"0.57741135",
"0.5741468",
"0.57067496",
"0.56141937",
"0.5591263",
"0.55796385",
"0.55761456",
"0.5559249",
"0.55478936",
"0.5541832",
"0.551966",
"0.54970336",
"0.5482063",
"0.5480211",
"0.5455... | 0.0 | -1 |
Groupwise groupwise resnik similarity assumes no negative phenotypes | def groupwise_jaccard(
self,
profiles: Iterable[Iterable[str]],
predicate: Optional[URIRef] = RDFS['subClassOf']) -> float:
# Filter out negative phenotypes
profile_union = set()
profile_intersection = set()
is_first = True
for profile in prof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def similarity_search(self):\n self.ssr = {gene: self.ssw.get_phenotypically_similar_genes(phenotypes, taxon=self.taxon) for gene, phenotypes in self.gene2phenotype_associations.items()}\n self.results = [ssr.get_results() for ssr in self.ssr.values()]\n self.phenogene_score = reduce(lambda x,... | [
"0.6074496",
"0.5989522",
"0.58322316",
"0.58266366",
"0.5814719",
"0.57938486",
"0.5773829",
"0.5740542",
"0.5705434",
"0.56132936",
"0.55909264",
"0.55784863",
"0.5575504",
"0.555807",
"0.554731",
"0.5541382",
"0.5519505",
"0.549608",
"0.54813904",
"0.54790777",
"0.5456131"... | 0.0 | -1 |
Groupwise jaccard similarty Negative phenotypes must be prefixed with a '' | def jaccard_sim(
self,
profile_a: Iterable[str],
profile_b: Iterable[str],
predicate: Optional[URIRef] = RDFS['subClassOf']) -> float:
# Filter out negative phenotypes
profile_a = {pheno for pheno in profile_a if not pheno.startswith("-")}
profile_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testStereo(self):\r\n smi_and_cansmi = [\r\n ('OC(=O)[C@@H](CCC(N)=O)N', 'NC(=O)CC[C@@H](N)C(=O)O'),\r\n ('OC(=O)[C@H](CCC(N)=O)N', 'NC(=O)CC[C@H](N)C(=O)O'),\r\n ('N[C@@H](C(O)=O)CCC(N)=O', 'NC(=O)CC[C@@H](N)C(=O)O'),\r\n ('N[C@H](C(O)=O)CCC(N)=O', 'NC(=O)CC[C@H](N)C(=O)O'),\r\n ('OC(=O)[C@H](N)CCC(N)=... | [
"0.5364827",
"0.5348201",
"0.5263061",
"0.5240012",
"0.5231654",
"0.5199887",
"0.51645106",
"0.51091814",
"0.50867844",
"0.5067651",
"0.50156325",
"0.5011522",
"0.49848363",
"0.49847978",
"0.4957041",
"0.49460623",
"0.49384376",
"0.49353865",
"0.4918157",
"0.49098793",
"0.490... | 0.0 | -1 |
Only implemented for same species comparisons | def _get_optimal_matrix(
self,
profile: Iterable[str],
is_same_species: Optional[bool]=True,
sim_measure: Union[PairwiseSim, None]= PairwiseSim.IC
) -> List[List[float]]:
score_matrix = []
if is_same_species:
for pheno in profile:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testSpeciesRichnessCorrect(self):\n self.assertEqual(136, self.coal.get_species_richness(1))\n self.assertNotEqual(self.coal.get_species_richness(2), self.coal.get_species_richness(1))\n self.assertNotEqual(self.coal.get_species_richness(3), self.coal.get_species_richness(2))",
"def test... | [
"0.6305768",
"0.6258834",
"0.6234448",
"0.617779",
"0.61766046",
"0.6141808",
"0.6101611",
"0.6086989",
"0.60863626",
"0.6077502",
"0.606582",
"0.606582",
"0.59950227",
"0.5986544",
"0.5962659",
"0.5879858",
"0.5867814",
"0.58432573",
"0.58421534",
"0.58362603",
"0.583577",
... | 0.0 | -1 |
return a dictionary containing the wordfrequencies in txt | def countwords(txt):
words = {}
pattern = re.compile("[a-zA-Z][a-zA-Z0-9]*")
for word in pattern.findall(txt):
words[word.lower()] = words.get(word,0)+1
# i'd rather do this in the prior step
# but i need to be able to eliminate dupes
# which may or may not be more expensive than
# going this route. ne... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def word_frequency():\n\n song = open(\"data/yellow_submarine.txt\")\n d = dict()\n for line in song:\n line = line.strip()\n line = line.lower()\n punctuations = \"\"\"!()-[]{};:'\"\\,<>./?@#$%^&*_~\"\"\" # remove punctuation https://www.programiz.com/python-programming/examples/rem... | [
"0.82302076",
"0.7872736",
"0.78641933",
"0.7768951",
"0.7765616",
"0.77622294",
"0.7686021",
"0.76753926",
"0.7661278",
"0.7654679",
"0.7622297",
"0.75752175",
"0.75617474",
"0.7512178",
"0.75015754",
"0.74849534",
"0.7483613",
"0.74421275",
"0.7441345",
"0.74296606",
"0.741... | 0.7190278 | 39 |
test loading the odmldictionary from an odmlfile | def test_load_from_file(self):
filename = 'tmp_testfile.odml'
doc = create_small_test_odml()
odml.tools.xmlparser.XMLWriter(doc).write_file(filename)
self.test_table.load_from_file(filename)
os.remove(filename)
self.assertDictEqual(self.test_table._odmldict[0], self.expec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_load_from_odmldoc(self):\n doc = create_small_test_odml()\n self.test_table.load_from_odmldoc(doc)\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)",
"def test_xml_from_dict(self):\n d = make_section_dict() # using default values\n e = dict_to_xm... | [
"0.73493034",
"0.63768405",
"0.6335154",
"0.63199216",
"0.62739456",
"0.6160915",
"0.60899967",
"0.6007868",
"0.5986313",
"0.5972034",
"0.5949016",
"0.5922218",
"0.5849775",
"0.5839075",
"0.5780473",
"0.57775825",
"0.5774112",
"0.5765218",
"0.5759872",
"0.56869483",
"0.568534... | 0.69646496 | 1 |
test loading the odmldictionary from a function that generates an odmldocument in python | def test_load_from_function(self):
self.test_table.load_from_function(create_small_test_odml)
self.assertEqual(self.test_table._odmldict, self.expected_odmldict) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_load_from_odmldoc(self):\n doc = create_small_test_odml()\n self.test_table.load_from_odmldoc(doc)\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)",
"def test_xml_from_dict(self):\n d = make_section_dict() # using default values\n e = dict_to_xm... | [
"0.7055841",
"0.6399399",
"0.629624",
"0.6255766",
"0.6005849",
"0.58549315",
"0.5843046",
"0.57319105",
"0.56690025",
"0.56592035",
"0.5652724",
"0.564667",
"0.56174755",
"0.5470184",
"0.5461585",
"0.5424229",
"0.5419281",
"0.5410989",
"0.5406271",
"0.53566486",
"0.5356169",... | 0.6571868 | 1 |
test loading the odmldictionary from an odmldocument in python | def test_load_from_odmldoc(self):
doc = create_small_test_odml()
self.test_table.load_from_odmldoc(doc)
self.assertEqual(self.test_table._odmldict, self.expected_odmldict) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_xml_from_dict(self):\n d = make_section_dict() # using default values\n e = dict_to_xml_str(d)\n e = prettify(e)\n\n if SHOW_RESULTS:\n print(e)\n\n xml_file = StringIO(unicode(e))\n self.assertTrue(verify_files(xml_file, open(SECTION_DTD_FILENAME, 'r... | [
"0.66436166",
"0.6631061",
"0.63010484",
"0.6263932",
"0.6065434",
"0.5871491",
"0.5856726",
"0.58290565",
"0.5812052",
"0.57576835",
"0.570343",
"0.56942403",
"0.569137",
"0.56734204",
"0.5655634",
"0.5608455",
"0.5434966",
"0.54257333",
"0.54153776",
"0.5407967",
"0.5405757... | 0.7528738 | 0 |
test writing the odmldict back to an odmlfile | def test_write2odml(self):
file1 = 'test.odml'
file2 = 'test2.odml'
doc = create_showall_test_odml()
self.test_table.load_from_odmldoc(doc)
odml.tools.xmlparser.XMLWriter(doc).write_file(file1)
self.test_table.change_header(Path=1, SectionName=2, SectionType=3,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_write_otu_map(self):\r\n write_otu_map(self.otu_map1, self.tmp_fp1)\r\n actual = fields_to_dict(open(self.tmp_fp1))\r\n self.files_to_remove.append(self.tmp_fp1)\r\n self.assertEqual(actual, dict(self.otu_map1))",
"def test_to_yaml_file(self):\n\n output_file = \"this_... | [
"0.6853921",
"0.6311872",
"0.6305071",
"0.62486225",
"0.6163576",
"0.61575305",
"0.6150572",
"0.60996205",
"0.60490966",
"0.60289615",
"0.6019624",
"0.59853345",
"0.5928576",
"0.5922343",
"0.5919674",
"0.59140754",
"0.58988816",
"0.58934546",
"0.588118",
"0.5879751",
"0.58667... | 0.73333204 | 0 |
Tests simple changing of the header | def test_simple_change(self):
self.test_table.change_header(Path=1, SectionType=2, Value=3)
self.assertListEqual(self.test_table._header, ["Path", "SectionType", "Value"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_writeHeader(self):\n output = StringIO()\n self.builder._writeHeader(output, \"Super Awesometastic 32.16\")\n self.assertEquals(\n output.getvalue(),\n \"Super Awesometastic 32.16\\n\"\n \"=========================\\n\"\n \"\\n\")",
"def t... | [
"0.7544321",
"0.72812474",
"0.7119248",
"0.7069106",
"0.6896639",
"0.67925715",
"0.6785979",
"0.6742433",
"0.67369777",
"0.6679956",
"0.66730666",
"0.6649584",
"0.66406304",
"0.6597778",
"0.6588827",
"0.65872717",
"0.65521425",
"0.654375",
"0.6513251",
"0.6502351",
"0.6430927... | 0.72789085 | 2 |
Test change_header with using the index 0 | def test_index_zero(self):
# TODO: change as exception is changed
with self.assertRaises(Exception):
self.test_table.change_header(Path=0, SectionType=1, Value=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_simple_change(self):\n self.test_table.change_header(Path=1, SectionType=2, Value=3)\n self.assertListEqual(self.test_table._header, [\"Path\", \"SectionType\", \"Value\"])",
"def new_run_header(self, changed):\n self.header = changed['value']",
"def _change_header(self, add=False... | [
"0.7514613",
"0.73269546",
"0.7090908",
"0.6776127",
"0.6765592",
"0.6551269",
"0.64034045",
"0.6308649",
"0.63084644",
"0.6293947",
"0.62860954",
"0.6206916",
"0.61824155",
"0.6169314",
"0.6143755",
"0.6130622",
"0.6123333",
"0.6118251",
"0.6113637",
"0.6082598",
"0.60699934... | 0.7285697 | 2 |
Test change_header with using a negative index | def test_negative_index(self):
# TODO: change Exception
with self.assertRaises(Exception):
self.test_table.change_header(Path=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_zero(self):\n # TODO: change as exception is changed\n with self.assertRaises(Exception):\n self.test_table.change_header(Path=0, SectionType=1, Value=2)",
"def test_same_indizes(self):\n # TODO: Exception\n with self.assertRaises(Exception):\n sel... | [
"0.7354142",
"0.64738077",
"0.6425895",
"0.63688374",
"0.61984",
"0.61857456",
"0.59954756",
"0.5904068",
"0.58630556",
"0.58415335",
"0.5813083",
"0.5781785",
"0.57639337",
"0.5730791",
"0.5705134",
"0.5682688",
"0.5682038",
"0.5677502",
"0.5618707",
"0.56174624",
"0.5609100... | 0.7583559 | 0 |
Test change_header leaving empty columns, while it is allowed | def test_empty_cols_allowed(self):
self.test_table.allow_empty_columns = True
self.test_table.change_header(Path=1, SectionType=3, Value=4)
self.assertEqual(self.test_table._header, ["Path", None, "SectionType",
"Value"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_simple_change(self):\n self.test_table.change_header(Path=1, SectionType=2, Value=3)\n self.assertListEqual(self.test_table._header, [\"Path\", \"SectionType\", \"Value\"])",
"def _reset_header(self):\n new_header = []\n for col_name in self.header:\n is_left = sel... | [
"0.6876637",
"0.6858973",
"0.6649065",
"0.6589102",
"0.653656",
"0.6475096",
"0.63742524",
"0.63540417",
"0.6284676",
"0.6265562",
"0.6252437",
"0.62409395",
"0.6202884",
"0.615543",
"0.6141923",
"0.61178464",
"0.61132544",
"0.6090016",
"0.607988",
"0.6033929",
"0.60301864",
... | 0.85452604 | 0 |
Test change_header with two columns with same indizes | def test_same_indizes(self):
# TODO: Exception
with self.assertRaises(Exception):
self.test_table.change_header(Path=1, SectionType=1, Value=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_simple_change(self):\n self.test_table.change_header(Path=1, SectionType=2, Value=3)\n self.assertListEqual(self.test_table._header, [\"Path\", \"SectionType\", \"Value\"])",
"def _reset_header(self):\n new_header = []\n for col_name in self.header:\n is_left = sel... | [
"0.6910554",
"0.6474417",
"0.6402902",
"0.61666656",
"0.6098005",
"0.596861",
"0.5965617",
"0.59317005",
"0.5931326",
"0.5920516",
"0.59009284",
"0.5865192",
"0.58465254",
"0.58213437",
"0.5803442",
"0.5784145",
"0.5766657",
"0.57511395",
"0.5730093",
"0.5730093",
"0.571732",... | 0.74366283 | 0 |
Test using change_header with a wrong keyword | def test_wrong_keyword(self):
# TODO: Exception
with self.assertRaises(Exception):
self.test_table.change_header(Path=1, Sectionname=2, Value=3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_run_header(self, changed):\n self.header = changed['value']",
"def test_simple_change(self):\n self.test_table.change_header(Path=1, SectionType=2, Value=3)\n self.assertListEqual(self.test_table._header, [\"Path\", \"SectionType\", \"Value\"])",
"def _change_header(self, add=False... | [
"0.70798177",
"0.68661684",
"0.6820545",
"0.6649878",
"0.65113676",
"0.62895864",
"0.627641",
"0.61753476",
"0.6167877",
"0.6147109",
"0.6130923",
"0.61227626",
"0.6109308",
"0.6108079",
"0.6078093",
"0.6064625",
"0.6055945",
"0.6051071",
"0.6036362",
"0.60006654",
"0.5975634... | 0.71992046 | 0 |
test filter function for exceptions | def test_filter_errors(self):
with self.assertRaises(ValueError):
self.test_table.filter()
with self.assertRaises(ValueError):
self.test_table.filter(mode='wrongmode', Property='Property') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no():\n errors = generate_errors(10, 5)\n assert NoFiltering().filter(errors) == errors",
"def test_filter_wea_zero_entry():\n pass",
"def test_filter_function_settings_fail(self):\n with self.assertRaises(TypeError):\n self.es.register_filter('test')",
"def test_filter_ar... | [
"0.7335465",
"0.70461434",
"0.7042257",
"0.69304",
"0.68743324",
"0.6845471",
"0.6814179",
"0.6778311",
"0.6695239",
"0.66767067",
"0.66699195",
"0.6629892",
"0.6619967",
"0.66138077",
"0.6492127",
"0.64911723",
"0.6485241",
"0.6461823",
"0.64462775",
"0.64022386",
"0.6386639... | 0.7170186 | 1 |
testing mode='and' setting of filter function | def test_filter_mode_and(self):
self.test_table.filter(mode='and', invert=False, SectionName='Section2',
PropertyName='Property2')
num_props_new = len(self.test_table._odmldict)
self.assertEqual(4, num_props_new) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_filter_mixed_function(self):\n for none_type in (False, True):\n for all_type in (False, True):\n for any_type in (False, True, None):\n result = none_type is False and all_type is True \\\n and (any_type is None or any_type is Tru... | [
"0.71120757",
"0.7084195",
"0.6975936",
"0.69528186",
"0.6931888",
"0.68448734",
"0.6841734",
"0.6730904",
"0.66951007",
"0.6671455",
"0.665661",
"0.6653067",
"0.66391844",
"0.66206056",
"0.65459645",
"0.65271086",
"0.6492255",
"0.6486859",
"0.64367616",
"0.6436344",
"0.64327... | 0.72008437 | 0 |
testing mode='or' setting of filter function | def test_filter_mode_or(self):
self.test_table.filter(mode='or', invert=False, SectionName='Section2',
PropertyName='Property2')
num_props_new = len(self.test_table._odmldict)
self.assertEqual(17, num_props_new) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_filter_mixed_function(self):\n for none_type in (False, True):\n for all_type in (False, True):\n for any_type in (False, True, None):\n result = none_type is False and all_type is True \\\n and (any_type is None or any_type is Tru... | [
"0.7074164",
"0.70579433",
"0.68908054",
"0.66604334",
"0.6529262",
"0.6468033",
"0.6421366",
"0.64113307",
"0.64006317",
"0.6384421",
"0.63657236",
"0.63148713",
"0.631061",
"0.6309568",
"0.62671715",
"0.62601864",
"0.61788315",
"0.6172945",
"0.6154431",
"0.6132411",
"0.6123... | 0.73522913 | 0 |
testing invert setting of filter function | def test_filter_invert(self):
num_props_original = len(self.test_table._odmldict)
self.test_table.filter(mode='or', invert=True, SectionName='Section2',
PropertyName='Property2')
num_props_new = len(self.test_table._odmldict)
self.assertEqual(num_props_or... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __invert__(self):\n not_filter = proto.FilterExpression()\n not_filter.filter_not.filter_expression.MergeFrom(self.filter)\n self.filter = not_filter\n return self",
"def test_correct_inverted(self):\n tests = [\n 'test.1',\n 'test.2',\n ]\n expected = '-test.1:... | [
"0.6876437",
"0.68602055",
"0.6728277",
"0.6673018",
"0.6657147",
"0.6627065",
"0.6543956",
"0.6442179",
"0.6409801",
"0.6360206",
"0.63267076",
"0.6269517",
"0.62632096",
"0.62427104",
"0.6204994",
"0.61974835",
"0.6171017",
"0.61681014",
"0.61410177",
"0.61259997",
"0.61069... | 0.6857319 | 2 |
testing recursive setting of filter function | def test_filter_recursive(self):
# total_number of properties
doc = self.test_table.convert2odml()
tot_props = len(list(doc.iterproperties()))
sec2s = list(doc.itersections(filter_func=lambda x: x.name == 'Section2'))
sec2_props = sum([len(list(sec.properties)) for sec in sec2s]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_filter_files(self):\n expected = [\n (\"/subdir1/fichier1\", False),\n (\"/subdir1/fichier4\", False),\n (\"/subdir1/subsubdir1\", False),\n ]\n files = [\n (\"/subdir1/fichier1\", False),\n (\"/subdir2/fichier2\", False),\n ... | [
"0.6639373",
"0.65807915",
"0.6568952",
"0.6459897",
"0.6399126",
"0.6363952",
"0.6329797",
"0.632054",
"0.62691253",
"0.6231018",
"0.6215396",
"0.6181549",
"0.61160463",
"0.6099278",
"0.6092511",
"0.608301",
"0.60665554",
"0.6002192",
"0.599707",
"0.59557116",
"0.5904092",
... | 0.59760326 | 19 |
keeping/removing all properties by providing True/False as comparison function | def test_filter_comparison_func_false(self):
num_props_original = len(self.test_table._odmldict)
self.test_table.filter(comparison_func=lambda x, y: True, PropertyName='')
self.assertEqual(len(self.test_table._odmldict), num_props_original)
self.test_table.filter(comparison_func=lambda... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_by(self, property):\n for length in range(len(self)):\n for p in list(self[length]):\n if not property(p):\n self[length].remove(p)",
"def all_safe_properties(obj):\n return tuple(set(all_properties(obj)).difference(__leave_alone_properties))",
... | [
"0.6667049",
"0.6053444",
"0.6053444",
"0.5640798",
"0.5633678",
"0.5573169",
"0.5535688",
"0.5483396",
"0.5426049",
"0.5421662",
"0.5421662",
"0.5421662",
"0.5421662",
"0.53535455",
"0.5340078",
"0.533519",
"0.52904385",
"0.52695805",
"0.52648556",
"0.52213174",
"0.52142584"... | 0.6413872 | 1 |
To get a list of online, offline and expired minions | def minion_connection_stats(self, minions):
online_minions = list()
offline_minions = list()
expired_minions = list()
for minion_obj in minions:
# get UTC current date time
current_datetime = datetime.datetime.utcnow()
current_datetime = current_dat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_online_list(self) -> list:\n return self._get_json(self._URLS['GetOnlineList'])[1:]",
"def online_users(room):\n threshold = datetime.now() - timedelta(seconds=10)\n authorizations = models.Authorization.gql(\"WHERE room = :room AND last_checked_in >= :threshold\", room=room, threshold=threshold... | [
"0.6179117",
"0.5670039",
"0.56596464",
"0.56206715",
"0.5576873",
"0.5521085",
"0.55119115",
"0.54945326",
"0.5451108",
"0.5447861",
"0.54452866",
"0.5332441",
"0.5273542",
"0.5248664",
"0.52449083",
"0.52443904",
"0.5243403",
"0.52403325",
"0.5237741",
"0.52286935",
"0.5225... | 0.6905272 | 0 |
To show the key stats for the minions | def minion_key_stats(self, minions):
accepted_minions = list()
deleted_minions = list()
pending_minions = list()
for minion_obj in minions:
# get a list of accepted
if minion_obj.key_status == 0: # accepted
accepted_minions.append(minion_obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stats(self):",
"def printMajors(self):\n import mush\n skills = mush.combatSkills+mush.magicSkills+mush.stealthSkills\n for className, stats in sorted(self.classStats.items()):\n print className,'-------------------------------'\n skillStats = [(key,value) for key,v... | [
"0.58576655",
"0.58070374",
"0.57535034",
"0.5691368",
"0.56557524",
"0.562826",
"0.5623027",
"0.5588611",
"0.5494763",
"0.5487488",
"0.548133",
"0.54804647",
"0.5475366",
"0.5453144",
"0.54470354",
"0.5429701",
"0.5409322",
"0.5399024",
"0.5391455",
"0.5381971",
"0.5376132",... | 0.6644181 | 0 |
Send JSON statistics for AngularJS to consume | def list(self, request, *args, **kwargs):
# get minions per target
tid = self.request.QUERY_PARAMS.get("tid", None)
# get minions per target
qtid = self.request.QUERY_PARAMS.get("qtid", False)
if tid:
try:
target_obj = Target.objects.get(id=tid)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stats():\n return jsonify(shorten.get_stats(get_db(), app.config['MINI_URL_BASE']))",
"def ajax_get_statistics():\r\n return jsonify(generate_statistics())",
"def stats():\n stats = {\n \"Amenity\": \"amenities\",\n \"City\": \"cities\",\n \"Place\": \"places\",\n \"Rev... | [
"0.705334",
"0.70310396",
"0.65896904",
"0.652585",
"0.64211756",
"0.6405187",
"0.6320912",
"0.63191676",
"0.62984854",
"0.6242644",
"0.6215966",
"0.61851025",
"0.61801594",
"0.6151943",
"0.61514914",
"0.61466897",
"0.61080056",
"0.6086823",
"0.60247207",
"0.60211957",
"0.600... | 0.0 | -1 |
poll_git._retrieve_data Recursive function to retrieve all the repositories returned from git containing the supplied keyword. Git paginates the return values instead of supplying the entire list. Initially this call will retrieve page 1 and then recursively call itself incrementing the page number until an error code ... | def _retrieve_data(keyw, limit, page=1):
# Max results per page is 100
per_page = limit if limit < 100 else 100
url = BASE_URL + QUALIFIERS % (keyw, per_page, page)
req = requests.get(url)
r_json = req.json()
if limit > 100:
r_json['items'].extend(_retrieve_data(keyw, limit - 100, pag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self, *args, **kwargs):\r\n\r\n if not self.current_repo:\r\n # get the first available repository\r\n self.current_repo = next(self.repo_list)\r\n\r\n if self.current_repo in self.repo_done:\r\n try:\r\n # get the next available repository\r\n... | [
"0.610186",
"0.545425",
"0.53882384",
"0.5294301",
"0.52345854",
"0.5152139",
"0.514462",
"0.5143252",
"0.50355893",
"0.50099504",
"0.5008395",
"0.4898757",
"0.4895922",
"0.48570067",
"0.4837202",
"0.4826648",
"0.48244652",
"0.48124608",
"0.4810986",
"0.47822344",
"0.4771593"... | 0.4916661 | 11 |
poll_git.filter_dict Utility method to remove all keys from a dict except those in the key set | def _filter_dict(src_dict, key_set):
for k in set(src_dict.keys()) - key_set:
src_dict.pop(k) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cleanse_dict(original):\n return {k: v for k, v in original.items() if \"_pass\" not in k}",
"def _cleanse_dict(original):\n return dict((k, v) for k, v in original.items() if \"_pass\" not in k)",
"def clean_dict(dictionary):\n return {k: v for k, v in dictionary.items() if v}",
"def clean_dic... | [
"0.7563569",
"0.7440057",
"0.7419116",
"0.7418322",
"0.740843",
"0.73695225",
"0.72462183",
"0.72018117",
"0.71871424",
"0.7120856",
"0.7070811",
"0.70674783",
"0.70619494",
"0.70096827",
"0.69330645",
"0.69295365",
"0.6927854",
"0.6914809",
"0.69089794",
"0.6890785",
"0.6881... | 0.81835246 | 0 |
The main function Print a JSON dictionary by polling github for the repositories containing a given keyword, ordered by the number of forks (descending). This main fun | def main():
# parse for provided arguments
parser = argparse.ArgumentParser()
# main is expecting only one arg - that being the test mode flag
# test mode flag will be used to optionally commit the db updates
# (i.e., if we are in test mode don't commit, do a rollback)
parser.add_argument('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\t\tn = 0 \n\t\tfor page in range(pages):\n\t\t\t\tpageNumber = str(page + 1)\n\t\t\t\tprint \"Processing page number \" + pageNumber\n\t\t\t\tpageUrl = 'https://api.github.com/users/' + USER + '/gists?page=' + pageNumber + '&per_page=' + str(int(perpage))\n\t\t\t\tu = urlopen (pageUrl)\n\t\t\t\tgist... | [
"0.6452412",
"0.637317",
"0.6333379",
"0.627017",
"0.6170934",
"0.5965858",
"0.59548104",
"0.5907087",
"0.58560294",
"0.57858473",
"0.5683087",
"0.5675596",
"0.56318",
"0.5599372",
"0.5572108",
"0.552574",
"0.55018026",
"0.5483693",
"0.5472313",
"0.5417226",
"0.54059106",
"... | 0.74229103 | 0 |
Constructor. socket to remote server to send data to lastmessage class containg the last recived message condition condition synchronization object | def __init__(self, socket,lastmessage, condition):
threading.Thread.__init__(self)
self.lastmessage = lastmessage
self.condition = condition
self.socket = socket | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, sock, address, name=\"\"):\n socket.setdefaulttimeout(0.01)\n self.socket = sock\n self.address = address\n self.name = name\n self.msg_id = 0",
"def __init__(self, serversocket, byte_count_size=BYTES_PER_SHORT):\n self.socket_, self.ip = serversocket.... | [
"0.6586863",
"0.6553067",
"0.65429056",
"0.64001745",
"0.63081723",
"0.62766576",
"0.6269248",
"0.62473345",
"0.61494416",
"0.6128056",
"0.60948056",
"0.60921746",
"0.6078823",
"0.60623664",
"0.6059222",
"0.6054902",
"0.6017394",
"0.5991975",
"0.5985619",
"0.59840095",
"0.597... | 0.80534434 | 0 |
Thread run method. Waits for reciver thread to release the condition then takes the last message if it exists and sends it to the remote server Inte ultimat kommer bli mycket samma data i slutandan om manga enheter skickar data | def run(self):
macId, sensorId = getRequest(self.socket)
try:
while True:
self.condition.acquire()
while True:
data = self.lastmessage.readData(macId, sensorId)
self.socket.send(str(data) + '\n')
#sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n errors = 0\n while ALIVE:\n try:\n self.maintainConn()\n try:\n line = self.reader.readerq.get(True, 5)\n except Empty:\n continue\n self.sendq.append(line)\n t... | [
"0.7166642",
"0.69733244",
"0.65547436",
"0.6510656",
"0.6484803",
"0.648338",
"0.64669335",
"0.6461319",
"0.6408202",
"0.6400174",
"0.639893",
"0.63459706",
"0.6325677",
"0.63164294",
"0.62975806",
"0.6293658",
"0.6275294",
"0.62307036",
"0.62262607",
"0.62159586",
"0.621569... | 0.7115101 | 1 |
Allow dictstyle item access by index (row id), or by row name ("key" column). | def __getitem__(self, i):
if isinstance(i, int):
if i >= len(self._section):
return Error('COPY.%s.%i [row index outside range]' % (self.name, i))
return self._section[i]
if i not in self._section:
return Error('Could not find attribute %s' % i)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, item):\n return self.row[item]",
"def __getitem__(self, rowcol):\n row, col = rowcol\n if col in self.colnames:\n col = self.colnames.index(col)\n return dict.__getitem__(self, (row, col))",
"def __getitem__(self, key):\n # Both row index and ... | [
"0.7226161",
"0.7202655",
"0.7111144",
"0.68057585",
"0.6513975",
"0.6475214",
"0.6341877",
"0.63327605",
"0.63160837",
"0.6302959",
"0.6272936",
"0.62418556",
"0.61779606",
"0.61148566",
"0.6079819",
"0.60519147",
"0.6024012",
"0.60066617",
"0.596928",
"0.5942441",
"0.593256... | 0.0 | -1 |
Allow dictstyle item access by sheet name. | def __getitem__(self, name):
print self, name
if name not in self._copy:
return Error('COPY.%s [sheet does not exist]' % name)
return self._copy[name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, name):\n return self.entry[name]",
"def getSheet(self, sheet_name):\r\n return self.workbook.Sheets(sheet_name)",
"def __getitem__(self, name):\n return self._items[name.lower()][1]",
"def get_sheet_by_name(book, name):\n i = 0\n for sheetname in book.sheetnam... | [
"0.57084394",
"0.56994104",
"0.5615424",
"0.55837756",
"0.5518013",
"0.54978603",
"0.54660934",
"0.542593",
"0.5327343",
"0.5314083",
"0.5306283",
"0.5261978",
"0.525484",
"0.51877034",
"0.5173072",
"0.51332927",
"0.5125193",
"0.5108615",
"0.50948066",
"0.50918025",
"0.508553... | 0.6302345 | 0 |
Parses the downloaded Excel file. | def load(self):
try:
with open(self._filename) as f:
doc = archieml.load(f)
except IOError:
raise CopyException('"%s" does not exist. Have you run "fab update_copy"?' % self._filename)
for section in doc:
self._copy[section] = Section(section,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_ra():\r\n fname = 'parse/File1.xlsx'\r\n sheet_name = 'Sheet1'\r\n\r\n ra_sheet = get_sheet(fname, sheet_name)\r\n return parse_sheet(ra_sheet)",
"def Excel_Load_Data( self, ExcelFilename ):\n pass",
"def parse_xlsx(filename):\n from openpyxl import load_workbook\n\n workbook... | [
"0.6445948",
"0.58994526",
"0.58873886",
"0.573046",
"0.5705608",
"0.569733",
"0.56871164",
"0.56281763",
"0.5570489",
"0.5560211",
"0.555015",
"0.5517005",
"0.5507791",
"0.54691666",
"0.5464367",
"0.54502684",
"0.54298306",
"0.53358257",
"0.5281962",
"0.52774864",
"0.5259692... | 0.0 | -1 |
backSub = cv.createBackgroundSubtractorKNN() kernel1 = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(2,2)) kernel2 = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(2,2)) kernel1 = np.ones((3,3),np.uint8) kernel2 = np.ones((3,3), np.uint8) fgMask = cv.threshold(fgMask, 100, 255, cv.THRESH_BINARY)[1] f... | def img_process(fgMask):
backSub = cv.createBackgroundSubtractorKNN()
kernel1 = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(2,2))
kernel2 = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(2,2))
#kernel1 = np.ones((3,3),np.uint8)
#kernel2 = np.ones((3,3), np.uint8)
fgMask = c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backgroundSubtraction(kmin, kmax, kwin=10,\n indir=IMG_DIR, inpattern=IMG_PATTERN,\n outdir=DIFF_DIR, outpattern=DIFF_PATTERN,\n verbose=True):\n\n def equalize_color(img):\n \"\"\"Apply histogram equalization to each channel... | [
"0.7177756",
"0.6724952",
"0.66178995",
"0.65937954",
"0.65740156",
"0.64842683",
"0.62351716",
"0.62128395",
"0.6182483",
"0.61607844",
"0.61557305",
"0.6147242",
"0.6139487",
"0.61274254",
"0.6097421",
"0.6093765",
"0.60761654",
"0.606649",
"0.605861",
"0.60537887",
"0.6052... | 0.8908296 | 0 |
login to get a access token | def login(self):
if not request.is_json:
return jsonify({"msg": "Invalid JSON format in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"msg": "Missing username"}), 400
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):\n r = self._login_token()",
"def login():\n req = request.get_json(force=True)\n username = req.get('username', None)\n password = req.get('password', None)\n user = guard.authenticate(username, password)\n ret = {'access_token': guard.encode_jwt_token(user)}\n return re... | [
"0.7869619",
"0.75151825",
"0.7474016",
"0.73700917",
"0.7323191",
"0.72778314",
"0.7277398",
"0.7256978",
"0.72330046",
"0.72143346",
"0.7192071",
"0.7190282",
"0.7180875",
"0.71671444",
"0.71606505",
"0.71599936",
"0.7129657",
"0.71291435",
"0.712277",
"0.7092429",
"0.70635... | 0.7270558 | 7 |
The m1 flavors are the original devstack flavors | def _filter_m1_flavors(self, results):
new_results = []
for flavor in results:
if flavor['name'].startswith("m1."):
new_results.append(flavor)
return new_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flavors(self, **kwargs):\n raise NotImplementedError",
"def flavors(self, **kwargs):\n if kwargs is None:\n result = self.get_list(self.cloudman.compute.flavors(),\n kind=\"flavor\")\n if \"name\" in kwargs:\n result = self.flavor(n... | [
"0.7495386",
"0.6508931",
"0.63442314",
"0.61788255",
"0.6131679",
"0.60157377",
"0.60098404",
"0.5906056",
"0.5867811",
"0.5835011",
"0.5785769",
"0.56962883",
"0.5615338",
"0.55481666",
"0.5546179",
"0.55272484",
"0.5484042",
"0.5467828",
"0.54599243",
"0.54354995",
"0.5431... | 0.6475194 | 2 |
Gets the title and ID of all tech skill entries | def to_tech_tuples(sort_index=None, reverse=False) -> List[Tuple[str, int]]:
global TSKILL_TITLEIDS
if TSKILL_TITLEIDS is None:
TSKILL_TITLEIDS = [(s.title, s.id) for s in Skill.query.all() if s.is_tech()]
if sort_index is None:
return TSKILL_TITLEIDS
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_skill(self):\n return ', '.join([skill.name for skill in self.skill.all()[:3]])",
"async def all_skills_data(self) -> AllSkillsData:\n return AllSkillsData(**await self.get(\"/skill/all\"))",
"def skill(self):\n return self._get(\"skill\")",
"def all_skill_list(self):\n ... | [
"0.6109518",
"0.6009882",
"0.59634143",
"0.5927496",
"0.5860163",
"0.5798118",
"0.5749347",
"0.567642",
"0.56626165",
"0.5646677",
"0.5619657",
"0.5611926",
"0.55326295",
"0.55326295",
"0.54883397",
"0.5464825",
"0.5450459",
"0.5429305",
"0.5427211",
"0.5374632",
"0.5367275",... | 0.5712788 | 7 |
Gets the title and ID of all business skill entries | def to_biz_tuples(sort_index=None, reverse=False) -> List[Tuple[str, int]]:
global BSKILL_TITLEIDS
if BSKILL_TITLEIDS is None:
BSKILL_TITLEIDS = [(s.title, s.id) for s in Skill.query.all() if s.is_biz()]
if sort_index is None:
return BSKILL_TITLEIDS
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_skill_list(self):\n data_skill_list = self.data_skill_list()\n self.skill_list = []\n for i in range(len(self.data_profile)):\n if 'skills' in self.data_profile[i].keys():\n for j in range(len(self.data_profile[i]['skills'])):\n for skills i... | [
"0.612198",
"0.58380324",
"0.58018816",
"0.56096494",
"0.5537682",
"0.5537494",
"0.5492644",
"0.54438794",
"0.5375623",
"0.5314642",
"0.5282276",
"0.52786386",
"0.524643",
"0.52381927",
"0.52173907",
"0.5148513",
"0.51434356",
"0.5092051",
"0.5056292",
"0.5050178",
"0.504325"... | 0.503975 | 22 |
Converts the education experience to a single int representing the minimum qualifications held. This is one higher than the EducationLevel values (0 = no education, 1 = certification, etc.) | def min_edu_level(self) -> int:
if len(self._history_edus) == 0:
return 0
# add one since allocating 0 for 'none'
return int(max([e.education_lvl for e in self._history_edus])) + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def base_experience(self) -> int:\n return self._base_experience",
"def min_weight(self):\n return self.experiences.min_weight",
"def scoreEducation(self, employee_ed, name):\n\n university = self.university\n schools = [school for school in name if school != \"\"]\n rank = [... | [
"0.6091574",
"0.60766613",
"0.5663413",
"0.5663034",
"0.5594252",
"0.5542864",
"0.5542864",
"0.54906315",
"0.5470742",
"0.54238975",
"0.5421171",
"0.53634584",
"0.5359417",
"0.5359417",
"0.5327927",
"0.5322198",
"0.53167486",
"0.5293654",
"0.5291187",
"0.5285667",
"0.5284425"... | 0.7296643 | 0 |
Get's the abbreviated degree name of the min education level. | def min_edu_abbv(self) -> str:
lvl = self.min_edu_level
if lvl == 0:
return "None"
elif lvl == 1:
return "Cert"
elif lvl == 2:
return "A.S."
elif lvl == 3:
return "B.S."
elif lvl == 4:
return "M.S."
elif ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_descriptive_name(self):\r\n long_name = str(self.year) + ' ' + self.make + ' ' + self.model\r\n #Mostrar_Grande = long_name.upper()\r\n #return long_name.upper()\r\n #return Mostrar_Grande #Funciona Com Return TAMBÉM, mas olhe na linha 39 como seria necessário usar.\r\n p... | [
"0.62686497",
"0.6171701",
"0.61384463",
"0.6117577",
"0.601304",
"0.5911395",
"0.5890063",
"0.587878",
"0.5854062",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58505285",
"0.58... | 0.70609176 | 0 |
Calculates the number of years of job experience held. | def years_job_experience(self) -> int:
return sum([job.years_employed for job in self._history_jobs]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_age(self):\n return CURRENT_YEAR - self.year",
"def get_age(self):\n return CURRENT_YEAR - self.year",
"def years_to_pay(self) -> float:\n return round(self.term / self.term_multiplier * self.n_periods / 12, 1)",
"def calculate_current_age(dob):\n today = datetime.date.today()... | [
"0.69628876",
"0.69628876",
"0.695793",
"0.68692875",
"0.6789864",
"0.67852265",
"0.6754551",
"0.6731187",
"0.6647829",
"0.6566959",
"0.65495574",
"0.652794",
"0.6518666",
"0.6416457",
"0.63934374",
"0.6276981",
"0.62368333",
"0.62318367",
"0.6229864",
"0.6219878",
"0.6218481... | 0.83394194 | 0 |
Converts an instance of this class to a dictionary (e.g., for JSONifying it) | def to_dict(self) -> dict:
d = dict()
d['id'] = self.id
d['name'] = self.full_name
d['email'] = self._user.email
d['phone'] = self.phone_number
d['location'] = self.location
ww = int(self.work_wanted)
d['work_types'] = {
'full': ww & 1 > 0,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self) -> Dict[str, Any]:\n return self.__dict__.copy()",
"def to_obj(self):\n return dict()",
"def to_dict(self):\n return to_dict(self.__dict__)",
"def to_dict(cls) -> dict:\n raise NotImplementedError()",
"def as_dict(self):\n return asdict(self)",
"def to... | [
"0.8173195",
"0.81439555",
"0.81402457",
"0.8138447",
"0.8130105",
"0.81093574",
"0.80859",
"0.8084972",
"0.80840886",
"0.8073715",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669",
"0.80669... | 0.0 | -1 |
Converts technical skills possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_tech_skills(self) -> int:
# skill_id skill_level
tskill_ids = [s.skill_id for s in self._skills if s._skill.is_tech()]
enc = ['0' for _ in range(Skill.count())]
for _id in tskill_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_roll_value_for_skill(self) -> int:\n if not self.skill:\n return 0\n base = self.character.traits.get_skill_value(self.skill)\n return StatWeight.get_weighted_value_for_skill(base)",
"def encode_biz_skills(self) -> int:\n # skill_id skill_level\n bskill_ids =... | [
"0.58784425",
"0.58267003",
"0.58267003",
"0.568689",
"0.5582021",
"0.54769146",
"0.543507",
"0.5429695",
"0.5407055",
"0.5396066",
"0.5337476",
"0.53325754",
"0.531957",
"0.53009146",
"0.51986206",
"0.5195058",
"0.5187859",
"0.5186852",
"0.5176883",
"0.5173365",
"0.5173365",... | 0.6798149 | 1 |
Converts business skills possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_biz_skills(self) -> int:
# skill_id skill_level
bskill_ids = [s.skill_id for s in self._skills if s._skill.is_biz()]
enc = ['0' for _ in range(Skill.count())]
for _id in bskill_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_roll_value_for_skill(self) -> int:\n if not self.skill:\n return 0\n base = self.character.traits.get_skill_value(self.skill)\n return StatWeight.get_weighted_value_for_skill(base)",
"def encode_tech_skills(self) -> int:\n # skill_id skill_level\n tskill_ids ... | [
"0.5716588",
"0.5670153",
"0.5670153",
"0.5512762",
"0.5461399",
"0.5459458",
"0.5413066",
"0.540013",
"0.5399135",
"0.53972685",
"0.53957635",
"0.5329288",
"0.5315077",
"0.52612674",
"0.52327406",
"0.52209467",
"0.52209467",
"0.51780355",
"0.5174286",
"0.51525414",
"0.513392... | 0.67850846 | 1 |
Converts attitudes possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_attitudes(self) -> int:
# skill_id skill_level
att_ids = [s.attitude_id for s in self._attitudes]
enc = ['0' for _ in range(Attitude.count())]
for _id in att_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_to_int(self, flag_dict):\n int_out = 0\n for key in list(flag_dict.keys()):\n fmask = self.flag_masks.get(key)\n if fmask is None:\n raise ValueError(\"key %s does not belong to this flag space\" % key)\n if flag_dict[key]:\n int... | [
"0.5455803",
"0.54509205",
"0.51860356",
"0.5156996",
"0.49522758",
"0.4859521",
"0.4824676",
"0.4801027",
"0.47986278",
"0.4791375",
"0.47847626",
"0.47815135",
"0.47674224",
"0.4722442",
"0.47131926",
"0.47098625",
"0.47098625",
"0.46894836",
"0.4670891",
"0.46690366",
"0.4... | 0.6402386 | 1 |
A string to represent the age of this post. | def age(self) -> str:
tdelta = dt.now() - self.created_timestamp
if tdelta.days >= 548: # enough to round it up to 2 years
return f'about {tdelta.days/365:.0f} years'
elif tdelta.days >= 345: # enough to round it up to 1 year (so it doesn't report '12 months')
return f'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def age(self):\n\n years, months, days = calculate_age(self.birthdate)\n if years:\n return \"%d year%s old\" % (years, \"s\" if years > 1 else \"\")\n elif months:\n return \"%d month%s old\" % (months, \"s\" if months > 1 else \"\")\n else:\n return \"... | [
"0.82187986",
"0.77554965",
"0.7717731",
"0.7594224",
"0.7593773",
"0.7579443",
"0.75256914",
"0.7522066",
"0.7522066",
"0.7522066",
"0.75171536",
"0.7515912",
"0.74829715",
"0.74518067",
"0.74498564",
"0.7447325",
"0.7446756",
"0.73713535",
"0.7241897",
"0.7241897",
"0.71139... | 0.8177297 | 1 |
Converts technical skills possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_tech_skills(self) -> int:
# skill_id skill_level
tskill_ids = [s.skill_id for s in self._skills if s._skill.is_tech()]
enc = ['0' for _ in range(Skill.count())]
for _id in tskill_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_roll_value_for_skill(self) -> int:\n if not self.skill:\n return 0\n base = self.character.traits.get_skill_value(self.skill)\n return StatWeight.get_weighted_value_for_skill(base)",
"def encode_biz_skills(self) -> int:\n # skill_id skill_level\n bskill_ids =... | [
"0.58784425",
"0.58267003",
"0.58267003",
"0.568689",
"0.5582021",
"0.54769146",
"0.543507",
"0.5429695",
"0.5407055",
"0.5396066",
"0.5337476",
"0.53325754",
"0.531957",
"0.53009146",
"0.51986206",
"0.5195058",
"0.5187859",
"0.5186852",
"0.5176883",
"0.5173365",
"0.5173365",... | 0.6798149 | 0 |
Converts business skills possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_biz_skills(self) -> int:
# skill_id skill_level
bskill_ids = [s.skill_id for s in self._skills if s._skill.is_biz()]
enc = ['0' for _ in range(Skill.count())]
for _id in bskill_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_roll_value_for_skill(self) -> int:\n if not self.skill:\n return 0\n base = self.character.traits.get_skill_value(self.skill)\n return StatWeight.get_weighted_value_for_skill(base)",
"def encode_tech_skills(self) -> int:\n # skill_id skill_level\n tskill_ids ... | [
"0.5716588",
"0.5670153",
"0.5670153",
"0.5512762",
"0.5461399",
"0.5459458",
"0.5413066",
"0.540013",
"0.5399135",
"0.53972685",
"0.53957635",
"0.5329288",
"0.5315077",
"0.52612674",
"0.52327406",
"0.52209467",
"0.52209467",
"0.51780355",
"0.5174286",
"0.51525414",
"0.513392... | 0.67850846 | 0 |
Converts attitudes possessed to an integer. Only looks at whether the seeker added it to their profile. | def encode_attitudes(self) -> int:
# skill_id skill_level
att_ids = [s.attitude_id for s in self._attitudes]
enc = ['0' for _ in range(Attitude.count())]
for _id in att_ids:
enc[_id - 1] = '1'
return int(''.join(enc), base=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_to_int(self, flag_dict):\n int_out = 0\n for key in list(flag_dict.keys()):\n fmask = self.flag_masks.get(key)\n if fmask is None:\n raise ValueError(\"key %s does not belong to this flag space\" % key)\n if flag_dict[key]:\n int... | [
"0.5455803",
"0.54509205",
"0.51860356",
"0.5156996",
"0.49522758",
"0.4859521",
"0.4824676",
"0.4801027",
"0.47986278",
"0.4791375",
"0.47847626",
"0.47815135",
"0.47674224",
"0.4722442",
"0.47131926",
"0.47098625",
"0.47098625",
"0.46894836",
"0.4670891",
"0.46690366",
"0.4... | 0.6402386 | 0 |
Converts a city and state (both optional) to the key expected by this table. | def to_location(city: str = None, state: str = None) -> str:
if city is None and state is None:
return "USA"
elif city is None or state is None:
return f"{city or ''}{state or ''}, USA"
return f"{city}, {state} USA" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def site_to_key(site, state=\"\"):\n if type(state) != str:\n raise Exception(\"`state` must be a string.\")\n return \",\".join([str(l) for l in site]) + state",
"def _state_agg_key(location_type, record: dict) -> Optional[str]:\n if record[f\"{location_type}_state_code\"] is None:\n retu... | [
"0.60184586",
"0.5755065",
"0.54741406",
"0.54564816",
"0.5452006",
"0.52865285",
"0.50954854",
"0.50830144",
"0.5069444",
"0.50618964",
"0.5060401",
"0.5007043",
"0.49998912",
"0.49536315",
"0.49146366",
"0.49133226",
"0.49112546",
"0.48750046",
"0.48591265",
"0.48470807",
"... | 0.5396536 | 5 |
Gets the coordinates for the given city and/or state. If fallback is true, it will attempt to get the closest matching result (just state if city cannot be found, otherwise just 'USA') | def get(city: str = None, state: str = None, fallback=True) -> Tuple[float, float]:
loc_id = LocationCoordinates.to_location(city, state)
row = LocationCoordinates.query.get(loc_id)
if row is None:
# not present, create then return
loc_obj = geolocator.geocode(loc_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_coordinates_for_city(city, state=None):\n search_str = ', '.join([city, state]) if state else city\n db_coords = get_coordinates_from_db(search_str)\n if db_coords:\n return (search_str, db_coords)\n else:\n page_title, coords = get_coordinates_from_wikipedia(search_str)\n ... | [
"0.68224823",
"0.6361756",
"0.615891",
"0.6116001",
"0.60422117",
"0.5858442",
"0.58064425",
"0.5731553",
"0.5635527",
"0.5595735",
"0.5581862",
"0.5567429",
"0.5552811",
"0.5550357",
"0.5547978",
"0.5525822",
"0.5514432",
"0.5505999",
"0.55029947",
"0.5498044",
"0.5496425",
... | 0.79270655 | 0 |
Run once, or forever, depending on config. | def run(self):
if self.config.daemon():
self.logger.info("Running forever, in a loop")
self.run_forever()
else:
self.logger.info("Running once, to completion")
self.run_once() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_forever(self):\n while True:\n self.run_once()\n\n self.logger.info(f\"Sleeping for {self.config.sleep()} seconds\")\n time.sleep(self.config.sleep())",
"def run_forever(self):\n self.factory.manager.run_forever()",
"def _run_once(self):\n try:\n s... | [
"0.72144735",
"0.6544273",
"0.65426034",
"0.6278244",
"0.62634057",
"0.62595147",
"0.62210196",
"0.6201465",
"0.6139407",
"0.6137481",
"0.61167115",
"0.61131215",
"0.6071008",
"0.6063917",
"0.6063917",
"0.60003394",
"0.59724736",
"0.59668356",
"0.5963748",
"0.5945622",
"0.593... | 0.73165596 | 0 |
Run each source once, passing artifacts to each operator. | def run_once(self):
# Track some statistics about artifacts in a summary object.
summary = collections.Counter()
for source in self.sources:
# Run the source to collect artifacts.
self.logger.info(f"Running source '{source}'")
try:
# get the g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n\t\tfor source in self.sources:\n\t\t\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\n\t\t\tfor r in source.get_elements():\n\t\t\t\tr.set_source(source)\n\t\t\t\tself._queue.put(r)\n\n\t\t\t\t# Extra tracking stuff below:\n\t\t\t\twith self._c_lock:\n\t\t\t... | [
"0.6483219",
"0.62053764",
"0.59726936",
"0.5708577",
"0.56067014",
"0.5595243",
"0.5565407",
"0.55493075",
"0.5513938",
"0.5458577",
"0.54373556",
"0.53742665",
"0.5362166",
"0.5355955",
"0.5340015",
"0.53185433",
"0.53077227",
"0.5302345",
"0.5282659",
"0.52769977",
"0.5276... | 0.77062124 | 0 |
Run forever, sleeping for the configured interval between each run. | def run_forever(self):
while True:
self.run_once()
self.logger.info(f"Sleeping for {self.config.sleep()} seconds")
time.sleep(self.config.sleep()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop_forever(self):\n while self.running:\n time.sleep(0.01)",
"def loop_forever(self):\n self.running = True\n while self.running:\n time.sleep(0.1)",
"def run(self, forever=False, interval=300):\n\n bot_start_time = time.time()\n\n while True:\n ... | [
"0.79261065",
"0.769201",
"0.72684103",
"0.71911734",
"0.7044903",
"0.70315796",
"0.70266116",
"0.69642824",
"0.6942898",
"0.68407226",
"0.6816066",
"0.6797461",
"0.6692905",
"0.6683687",
"0.6659617",
"0.6603098",
"0.65500087",
"0.64913917",
"0.64811295",
"0.6433807",
"0.6433... | 0.83757216 | 0 |
Return a dictionary with counts of each artifact type. | def artifact_types(artifact_list):
types = {}
for artifact in artifact_list:
artifact_type = artifact.__class__.__name__.lower()
if artifact_type in types:
types[artifact_type] += 1
else:
types[artifact_type] = 1
return types | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_freq(self, types=1):\n count_dict = {}\n if types == 1:\n for cat in self.categories:\n num_images = sum(\n [1 for i in self.data['annotations'] if i['category_id'] == self.cats_idx[cat]])\n count_dict[cat] = num_images\n el... | [
"0.66775286",
"0.6509573",
"0.645103",
"0.64237165",
"0.6420531",
"0.6405249",
"0.6346786",
"0.62873185",
"0.6284339",
"0.6173281",
"0.6121569",
"0.60898113",
"0.606048",
"0.5977172",
"0.5975826",
"0.5950914",
"0.5877489",
"0.5843365",
"0.5820288",
"0.5796875",
"0.5769143",
... | 0.817184 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.