def use_anime(self, provider, info): """ Setup method to define anime search parameters Args: provider (str): Provider ID payload (dict): Elementum search payload """ definition = definitions[provider] definition = get_alias(definition, get_setting("%s_alias" % provider)) if get_setting("use_public_dns", bool) and "public_dns_alias" in definition: definition = get_alias(definition, definition["public_dns_alias"]) anime_query = definition['anime_query'] if definition[ 'anime_query'] else '' log.debug("[%s] Anime URL: %s%s" % (provider, definition['base_url'], anime_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_episodes')) self.max_size = get_float(get_setting('max_size_episodes')) self.check_sizes() self.info = info self.url = u"%s%s" % (definition['base_url'], anime_query) if self.info['absolute_number']: self.info['episode'] = self.info['absolute_number'] if definition['anime_keywords']: self.queries = ["%s" % definition['anime_keywords']] self.extras = [ "%s" % definition['anime_extra'] if definition['anime_extra'] else '' ] if 'anime_keywords_fallback' in definition and definition[ 'anime_keywords_fallback']: self.queries.append(definition['anime_keywords_fallback']) self.extras.append('-')
def use_episode(self, provider, payload): """ Setup method to define episode search parameters Args: provider (str): Provider ID payload (dict): Elementum search payload """ definition = definitions[provider] definition = get_alias(definition, get_setting("%s_alias" % provider)) show_query = definition['show_query'] if definition[ 'show_query'] else '' log.debug("Episode URL: %s%s" % (definition['base_url'], show_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_episodes')) self.max_size = get_float(get_setting('max_size_episodes')) self.check_sizes() self.info = payload self.url = u"%s%s" % (definition['base_url'], show_query) if definition['tv_keywords']: self.queries = ["%s" % definition['tv_keywords']] self.extras = [ "%s" % definition['tv_extra'] if definition['tv_extra'] else '' ] # TODO this sucks, tv_keywords should be a list from the start.. if definition['tv_keywords2']: self.queries.append(definition['tv_keywords2']) self.extras.append( definition['tv_extra2'] if definition['tv_extra2'] else '')
def get_final_cost(ebay_item_obj, formula_obj, amazon_obj): price = re.findall("[0-9.]+", amazon_obj.get("price")) if len(price) > 0: price = get_float(float("".join(price))) print("initial price before formula", price) if ebay_item_obj.margin_perc: margin_perc = ebay_item_obj.margin_perc * price / 100 else: margin_perc = formula_obj.perc_margin * price / 100 if ebay_item_obj.minimum_margin: fixed_margin = ebay_item_obj.minimum_margin else: fixed_margin = formula_obj.fixed_margin cost = price + formula_obj.ebay_listing_fee + formula_obj.paypal_fees_fixed if margin_perc < fixed_margin: cost = cost + fixed_margin else: cost = cost + margin_perc p = 1 - ( (formula_obj.ebay_final_value_fee + formula_obj.paypal_fees_perc) / 100) cost_after_profit = get_float(cost / p) print("price after formula", cost_after_profit) return cost_after_profit
def use_season(self, provider, info): """ Setup method to define season search parameters Args: provider (str): Provider ID payload (dict): Elementum search payload """ definition = definitions[provider] definition = get_alias(definition, get_setting("%s_alias" % provider)) season_query = definition['season_query'] if definition[ 'season_query'] else '' log.debug("Season URL: %s%s" % (definition['base_url'], season_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_seasons')) self.max_size = get_float(get_setting('max_size_seasons')) self.check_sizes() self.info = info self.url = u"%s%s" % (definition['base_url'], season_query) if definition['season_keywords']: self.queries = ["%s" % definition['season_keywords']] self.extras = [ "%s" % definition['season_extra'] if definition['season_extra'] else '' ] if definition['season_keywords2']: self.queries.append("%s" % definition['season_keywords2']) self.extras.append("%s" % definition['season_extra2'] if definition['season_extra2'] else '')
def use_anime(self, provider, info): """ Setup method to define anime search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] anime_query = definition['anime_query'] if definition[ 'anime_query'] else '' log.debug("Anime URL: %s%s" % (definition['base_url'], anime_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_episodes')) self.max_size = get_float(get_setting('max_size_episodes')) self.check_sizes() self.info = info self.url = u"%s%s" % (definition['base_url'], anime_query) if self.info['absolute_number']: self.info['episode'] = self.info['absolute_number'] if definition['anime_keywords']: self.queries = ["%s" % definition['anime_keywords']] self.extras = [ "%s" % definition['anime_extra'] if definition['anime_extra'] else '' ]
def use_movie(self, provider, payload): """ Setup method to define movie search parameters Args: provider (str): Provider ID payload (dict): Elementum search payload """ definition = definitions[provider] definition = get_alias(definition, get_setting("%s_alias" % provider)) if get_setting("use_public_dns", bool) and "public_dns_alias" in definition: definition = get_alias(definition, definition["public_dns_alias"]) movie_query = definition['movie_query'] if definition[ 'movie_query'] else '' log.debug("[%s] Movies URL: %s%s" % (provider, definition['base_url'], movie_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_movies')) self.max_size = get_float(get_setting('max_size_movies')) self.check_sizes() self.info = payload self.url = u"%s%s" % (definition['base_url'], movie_query) if definition['movie_keywords']: self.queries = ["%s" % definition['movie_keywords']] self.extras = ["%s" % definition['movie_extra']] if 'movie_keywords2' in definition and definition['movie_keywords2']: self.queries.append("%s" % definition['movie_keywords2']) self.extras.append( "%s" % definition['movie_extra2'] if 'movie_extra2' in definition and definition['movie_extra2'] else '') if 'movie_keywords_fallback' in definition and definition[ 'movie_keywords_fallback']: self.queries.append(definition['movie_keywords_fallback']) self.extras.append('-')
def read(self, args, c): self.id, c = utils.get_int(args, c) self.x, c = utils.get_int(args, c) self.y, c = utils.get_int(args, c) self.health, c = utils.get_int(args, c) self.max_health, c = utils.get_int(args, c) self.shield, c = utils.get_int(args, c) self.max_shield, c = utils.get_int(args, c) self.energy, c = utils.get_int(args, c) self.maxCD, c = utils.get_int(args, c) self.groundCD, c = utils.get_int(args, c) self.airCD, c = utils.get_int(args, c) self.idle, c = utils.get_int(args, c) self.visible, c = utils.get_int(args, c) self.type, c = utils.get_int(args, c) self.armor, c = utils.get_int(args, c) self.shieldArmor, c = utils.get_int(args, c) self.size, c = utils.get_int(args, c) self.pixel_x, c = utils.get_int(args, c) self.pixel_y, c = utils.get_int(args, c) self.pixel_size_x, c = utils.get_int(args, c) self.pixel_size_y, c = utils.get_int(args, c) self.groundATK, c = utils.get_int(args, c) self.airATK, c = utils.get_int(args, c) self.groundDmgType, c = utils.get_int(args, c) self.airDmgType, c = utils.get_int(args, c) self.groundRange, c = utils.get_int(args, c) self.airRange, c = utils.get_int(args, c) n_orders, c = utils.get_int(args, c) if n_orders < 0: utils.print_err("Corrupted replay: n_orders < 0") return self.orders = [] for i in xrange(0, n_orders): self.orders.append(Order()) self.orders[i].first_frame, c = utils.get_int(args, c) self.orders[i].type, c = utils.get_int(args, c) self.orders[i].targetId, c = utils.get_int(args, c) self.orders[i].targetX, c = utils.get_int(args, c) self.orders[i].targetY, c = utils.get_int(args, c) self.velocityX, c = utils.get_float(args, c) self.velocityY, c = utils.get_float(args, c) self.playerId, c = utils.get_int(args, c) self.resources, c = utils.get_int(args, c) return c
def txn_to_obj_list(txn_string, amc=None, user_id=None): # TODO: in future, if amc is none, detect it from txn_string txn_matrix = parse_txn(txn_string) txn_obj_list = [] if amc.lower() == 'uti': positions = [0, 1, 2, 3, 4] elif amc.lower() == 'icici': positions = [0, 1, 5, 3, 2] else: raise for txn in txn_matrix: obj = dict(fund_name=txn[positions[0]], txn_type=txn[positions[1]], amount=utils.get_float(txn[positions[2]]), units=utils.get_float(txn[positions[3]]), date=utils.int_date(txn[positions[4]])) txn_obj_list.append(obj) for txn in txn_obj_list: if txn['txn_type'].lower() in ['purchase', 'new purchase', 'additional purchase']: txn['txn_type'] = PURCHASE elif txn['txn_type'].lower() in ['redemption']: txn['txn_type'] = REDEMPTION else: raise BaseException # Additional details contained in transactions if amc.lower() == 'uti': for obj, txn in zip(txn_obj_list, txn_matrix): obj['remarks'] = txn[6].strip() if len(txn) >= 7 else '' # DO NOT STORE ICICI NAV. IT IS SoMETIMES AN OLD VALUE # elif amc.lower() == 'icici': # for obj, txn in zip(txn_obj_list, txn_matrix): # obj['nav'] = float(txn[4]) for obj in txn_obj_list: obj['amc'] = amc.lower() if amc.lower() in ['icici', 'uti'] else '' for obj in txn_obj_list: obj['user_id'] = user_id # TODO Do not make this much api calls to db!! for obj in txn_obj_list: obj['fund_id'] = db.get_fund_id(obj['fund_name']) return txn_obj_list
def get_clear_price(p_str): f_str = None if p_str: price = re.findall("[0-9\.]+", p_str) if len(price) > 0: f_str = get_float(float("".join(price))) return f_str
def cleanup_results(results_list): # nothing found if len(results_list) == 0: return [] filtered_list = [] for result in results_list: # check provider returns seeds # get_int(result['seeds']) # append hash result['hash'] = Magnet(result['uri']).info_hash.upper() logger.log.debug(result['hash']) # remove dupes # noinspection PyTypeChecker if len([ item for item in filtered_list if item['hash'].upper() == result['hash'].upper() ]) == 0 or len(result['hash']) == 0: # append item to results filtered_list.append(result) return sorted(filtered_list, key=lambda r: (get_float(r['seeds'])), reverse=True)
def view_calibration(id): """View control page for a camera Args: id (str): Identifier name of camera Returns: HTML page """ # TODO: if no session['UPLOAD_TOKEN'], redirect to page that asks one. if not is_existing_id(id): return "", 404 small_url = url_for("image_view", id=id, image="small") crop_url = url_for("image_view", id=id, image="crop") state = load_state(id) if request.method == "POST": mode = request.form["mode"] state["server"]["mode"] = mode state["server"]["exposure_modifier"] = round( get_float(request.form["exposure_modifier"], 1.0), 2) refresh_state(id, state["server"], "server") state_view = json.dumps(state, indent=4, sort_keys=True) return render_template( "view.html", id=id, small_url=small_url, crop_url=crop_url, state=state, state_view=state_view, )
def size_clearance(cls, size): max_size1 = 100 if cls.max_size == 10 else cls.max_size res = False value = get_float(size) value *= 0.001 if 'M' in size else 1 if cls.min_size <= value <= max_size1: res = True return res
def __getitem__(mcs, item): # default values if item is "max_magnets": return get_int(mcs.value.get(item, "10")) elif item is "separator": return mcs.value.get(item, "%20") elif item is "time_noti": return get_int(mcs.value.get(item, "750")) elif item.endswith("accept"): temp = mcs.value.get(item, "{*}") return "{*}" if temp is "" else temp elif item.endswith("max_size"): return get_float(mcs.value.get(item, "10")) elif item.endswith("min_size"): return get_float(mcs.value.get(item, "0")) else: return mcs.value.get(item, "")
def use_movie(self, provider, payload): """ Setup method to define movie search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] movie_query = definition['movie_query'] if definition['movie_query'] else '' log.debug("Movies URL: %s%s" % (definition['base_url'], movie_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_movies')) self.max_size = get_float(get_setting('max_size_movies')) self.check_sizes() self.info = payload self.url = u"%s%s" % (definition['base_url'], movie_query) if definition['movie_keywords']: self.queries = ["%s" % definition['movie_keywords']] self.extras = ["%s" % definition['movie_extra']]
def __init__(self, fund_name=None, txn_type=None, amount=None, units=None, date=None, status=None, remarks=None): self.fund_name = fund_name if txn_type.lower() in ['purchase', 'new purchase', 'additional purchase']: self.txn_type = PURCHASE elif txn_type.lower() in ['redemption']: self.txn_type = REDEMPTION else: raise BaseException self.amount = utils.get_float(amount) self.units = utils.get_float(units) self.date = utils.int_date(date) self.status = status self.remarks = remarks self.fund_id = db.get_fund_id(fund_name) self.nav = None # NAV on the day the transaction is performed self.amc = None
def __getitem__(mcs, item): if item is "max_magnets": return get_int(mcs.value.get(item, "10")) elif item is "separator": return mcs.value.get(item, "%20") elif item is "notification": return get_int(mcs.value.get(item, "50")) elif item.endswith("accept"): temp = mcs.value.get(item, "{*}") return "{*}" if temp is "" else temp elif item.endswith("max_size"): return get_float(mcs.value.get(item, "10")) elif item.endswith("min_size"): return get_float(mcs.value.get(item, "0")) elif item.endswith("_title"): return mcs.value.get(item, "true") elif item.endswith("read_magnet_link"): return mcs.value.get(item, "false") else: return mcs.value.get(item, "")
def use_movie(self, provider, payload): """ Setup method to define movie search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] movie_query = definition['movie_query'] if definition[ 'movie_query'] else '' log.debug("Movies URL: %s%s" % (definition['base_url'], movie_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_movies')) self.max_size = get_float(get_setting('max_size_movies')) self.check_sizes() self.info = payload self.url = u"%s%s" % (definition['base_url'], movie_query) if definition['movie_keywords']: self.queries = ["%s" % definition['movie_keywords']] self.extras = ["%s" % definition['movie_extra']]
def use_anime(self, provider, info): """ Setup method to define anime search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] anime_query = definition['anime_query'] if definition['anime_query'] else '' log.debug("Anime URL: %s%s" % (definition['base_url'], anime_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_episodes')) self.max_size = get_float(get_setting('max_size_episodes')) self.check_sizes() self.info = info self.url = u"%s%s" % (definition['base_url'], anime_query) if self.info['absolute_number']: self.info['episode'] = self.info['absolute_number'] if definition['anime_keywords']: self.queries = ["%s" % definition['anime_keywords']] self.extras = ["%s" % definition['anime_extra'] if definition['anime_extra'] else '']
def use_season(self, provider, info): """ Setup method to define season search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] season_query = definition['season_query'] if definition['season_query'] else '' log.debug("Season URL: %s%s" % (definition['base_url'], season_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_seasons')) self.max_size = get_float(get_setting('max_size_seasons')) self.check_sizes() self.info = info self.url = u"%s%s" % (definition['base_url'], season_query) if definition['season_keywords']: self.queries = ["%s" % definition['season_keywords']] self.extras = ["%s" % definition['season_extra'] if definition['season_extra'] else ''] if definition['season_keywords2']: self.queries.append("%s" % definition['season_keywords2']) self.extras.append("%s" % definition['season_extra2'] if definition['season_extra2'] else '')
def use_episode(self, provider, payload): """ Setup method to define episode search parameters Args: provider (str): Provider ID payload (dict): Quasar search payload """ definition = definitions[provider] show_query = definition['show_query'] if definition['show_query'] else '' log.debug("Episode URL: %s%s" % (definition['base_url'], show_query)) if get_setting('separate_sizes', bool): self.min_size = get_float(get_setting('min_size_episodes')) self.max_size = get_float(get_setting('max_size_episodes')) self.check_sizes() self.info = payload self.url = u"%s%s" % (definition['base_url'], show_query) if definition['tv_keywords']: self.queries = ["%s" % definition['tv_keywords']] self.extras = ["%s" % definition['tv_extra'] if definition['tv_extra'] else ''] # TODO this sucks, tv_keywords should be a list from the start.. if definition['tv_keywords2']: self.queries.append(definition['tv_keywords2']) self.extras.append(definition['tv_extra2'] if definition['tv_extra2'] else '')
def size_clearance(cls, size): """ Convert string with size format to number ex: 1kb = 1000 :param size: string with the size format :type size: str :return: converter value in integer """ max_size1 = 100 if cls.max_size == 10 else cls.max_size res = False value = get_float(size) value *= 0.001 if 'M' in size else 1 if cls.min_size <= value <= max_size1: res = True return res
def __init__(self): resolutions = OrderedDict() resolutions['filter_240p'] = ['240p', 'tvrip', 'satrip', 'vhsrip'] resolutions['filter_480p'] = ['480p', 'xvid', 'dvd', 'dvdrip', 'hdtv'] resolutions['filter_720p'] = ['720p', 'hdrip', 'bluray', 'brrip', 'bdrip'] resolutions['filter_1080p'] = ['1080p', 'fullhd', '_fhd_'] resolutions['filter_2k'] = ['_2k_', '1440p'] resolutions['filter_4k'] = ['_4k_', '2160p'] self.resolutions = resolutions self.release_types = { 'filter_brrip': ['brrip', 'bdrip', 'bluray'], 'filter_webdl': ['webdl', 'webrip', 'web_dl', 'dlrip', '_yts_'], 'filter_hdrip': ['hdrip'], 'filter_hdtv': ['hdtv'], 'filter_dvd': ['_dvd_', 'dvdrip'], 'filter_dvdscr': ['dvdscr'], 'filter_screener': ['screener', '_scr_'], 'filter_3d': ['_3d_'], 'filter_telesync': ['telesync', '_ts_', '_tc_'], 'filter_cam': ['_cam_', 'hdcam'], 'filter_tvrip': ['tvrip', 'satrip'], 'filter_vhsrip': ['vhsrip'], 'filter_trailer': ['trailer'], 'filter_workprint': ['workprint'] } require = [] resolutions_allow = [] releases_allow = [] releases_deny = [] for resolution in self.resolutions: if get_setting(resolution, bool): resolutions_allow.append(resolution) # Add enabled resolutions to allowed release types to match # previous versions' behavior with certain providers # with no release types in torrent names, ie. YTS releases_allow.extend(self.resolutions[resolution]) self.resolutions_allow = resolutions_allow # Skip resolution filtering if we're allowing all of them anyway self.filter_resolutions = True if len(self.resolutions_allow) == len(self.resolutions): self.filter_resolutions = False for release_type in self.release_types: if get_setting(release_type, bool): releases_allow.extend(self.release_types[release_type]) else: releases_deny.extend(self.release_types[release_type]) self.releases_allow = releases_allow self.releases_deny = releases_deny if get_setting('additional_filters', bool): accept = get_setting('accept').strip().lower() if accept: accept = re.split(r',\s?', accept) releases_allow.extend(accept) block = get_setting('block').strip().lower() if block: block = re.split(r',\s?', block) releases_deny.extend(block) require = get_setting('require').strip().lower() if require: require = re.split(r',\s?', require) self.require_keywords = require self.min_size = get_float(get_setting('min_size')) self.max_size = get_float(get_setting('max_size')) self.check_sizes() self.filter_title = False self.queries = [] self.extras = [] self.info = dict(title="", titles=[]) self.kodi_language = '' self.language_exceptions = [] self.get_data = {} self.post_data = {} self.url = '' self.title = '' self.reason = '' self.results = []
def __init__(self): resolutions = OrderedDict() resolutions['filter_240p'] = ['240p', '_tvrip_', 'satrip', 'vhsrip'] resolutions['filter_480p'] = ['480p', 'xvid', 'dvd', 'dvdrip', 'hdtv'] resolutions['filter_720p'] = [ '720p', 'hdrip', 'bluray', 'brrip', 'bdrip' ] resolutions['filter_1080p'] = ['1080p', 'fullhd', '_fhd_'] resolutions['filter_2k'] = ['_2k_', '1440p'] resolutions['filter_4k'] = ['_4k_', '2160p'] self.resolutions = resolutions self.release_types = { 'filter_brrip': ['brrip', 'bdrip', 'bluray'], 'filter_webdl': ['webdl', 'webrip', 'web_dl', 'dlrip', '_yts_'], 'filter_hdrip': ['hdrip'], 'filter_hdtv': ['hdtv'], 'filter_dvd': ['_dvd_', 'dvdrip'], 'filter_dvdscr': ['dvdscr'], 'filter_screener': ['screener', '_scr_'], 'filter_3d': ['_3d_'], 'filter_telesync': ['telesync', '_ts_', '_tc_'], 'filter_cam': ['_cam_', 'hdcam'], 'filter_tvrip': ['_tvrip_', 'satrip'], 'filter_vhsrip': ['vhsrip'], 'filter_trailer': ['trailer'], 'filter_workprint': ['workprint'] } require = [] resolutions_allow = [] releases_allow = [] releases_deny = [] for resolution in self.resolutions: if get_setting(resolution, bool): resolutions_allow.append(resolution) # Add enabled resolutions to allowed release types to match # previous versions' behavior with certain providers # with no release types in torrent names, ie. YTS releases_allow.extend(self.resolutions[resolution]) self.resolutions_allow = resolutions_allow # Skip resolution filtering if we're allowing all of them anyway self.filter_resolutions = True if len(self.resolutions_allow) == len(self.resolutions): self.filter_resolutions = False for release_type in self.release_types: if get_setting(release_type, bool): releases_allow.extend(self.release_types[release_type]) else: releases_deny.extend(self.release_types[release_type]) self.releases_allow = releases_allow self.releases_deny = releases_deny if get_setting('additional_filters', bool): accept = get_setting('accept').strip().lower() if accept: accept = re.split(r',\s?', accept) releases_allow.extend(accept) block = get_setting('block').strip().lower() if block: block = re.split(r',\s?', block) releases_deny.extend(block) require = get_setting('require').strip().lower() if require: require = re.split(r',\s?', require) self.require_keywords = require self.min_size = get_float(get_setting('min_size')) self.max_size = get_float(get_setting('max_size')) self.check_sizes() self.filter_title = False self.queries = [] self.extras = [] self.info = dict(title="", titles=[]) self.kodi_language = '' self.language_exceptions = [] self.get_data = {} self.post_data = {} self.url = '' self.title = '' self.reason = '' self.results = []
def test_get_float(self): valid_inputs = [1, 1.2, '1', '1.2', '1,22.22', '1,23'] valid_outputs = [1.0, 1.2, 1.0, 1.2, 122.22, 123] for inp, out in zip(valid_inputs, valid_outputs): self.assertEqual(utils.get_float(inp), out) self.assertRaises(BaseException, utils.get_float, 'blah')
from utils import get_input, get_int, get_float, output_prices, get_room_summary from const import NAME, OCCUPANCY, COST print (''' ********************************************************************** * * * welcome to room bidder. let's start by answering a few questions * * * ********************************************************************** ''') num_rooms = get_int('number of rooms: ') total_price = get_float('total price of apartment: ') volatility_factory = total_price * .01 get_input(''' ***************** * INITIAL INPUT * ***************** {0} rooms at a total price of ${1:.2f} if this is not accurate, press CTRL+C and start over otherwise, press ENTER to continue '''.format(num_rooms, total_price)) print('to make things easier, let\'s name the rooms...') rooms = [] for index in range(num_rooms): rooms.append({ NAME: get_input('room #{0}: '.format(index+1)), COST: total_price/num_rooms
def __init__(self): resolutions = OrderedDict() # TODO: remove when finished with debugging resolutions detection # resolutions['filter_240p'] = ['240p', u'240р', '_tvrip_', 'satrip', 'vhsrip'] # resolutions['filter_480p'] = ['480p', u'480р', 'xvid', 'dvd', 'dvdrip', 'hdtv'] # resolutions['filter_720p'] = ['720p', u'720р', 'hdrip', 'bluray', 'blu_ray', 'brrip', 'bdrip', 'hdtv', '/hd720p', '1280x720'] # resolutions['filter_1080p'] = ['1080p', u'1080р', '1080i', 'fullhd', '_fhd_', '/hd1080p', '/hdr1080p', '1920x1080'] # resolutions['filter_2k'] = ['_2k_', '1440p', u'1440р', u'_2к_'] # resolutions['filter_4k'] = ['_4k_', '2160p', u'2160р', '_uhd_', u'_4к_'] resolutions['filter_240p'] = [u'240[pр]', u'vhs\-?rip'] resolutions['filter_480p'] = [ u'480[pр]', u'xvid|dvd|dvdrip|hdtv|web\-(dl)?rip|iptv|sat\-?rip|tv\-?rip' ] resolutions['filter_720p'] = [ u'720[pр]|1280x720', u'hd720p?|hd\-?rip|b[rd]rip' ] resolutions['filter_1080p'] = [ u'1080[piр]|1920x1080', u'hd1080p?|fullhd|fhd|blu\W*ray|bd\W*remux' ] resolutions['filter_2k'] = [u'1440[pр]', u'2k'] resolutions['filter_4k'] = [u'4k|2160[pр]|uhd', u'4k|hd4k'] resolutions['filter_music'] = [u'mp3|flac|alac|ost|sound\-?track'] self.resolutions = resolutions self.release_types = { 'filter_brrip': [u'brrip|bd\-?rip|blu\-?ray|bd\-?remux'], 'filter_webdl': [u'web_?\-?dl|web\-?rip|dl\-?rip|yts'], 'filter_hdrip': [u'hd\-?rip'], 'filter_hdtv': [u'hd\-?tv'], 'filter_dvd': [u'dvd|dvd\-?rip|vcd\-?rip'], 'filter_dvdscr': [u'dvd\-?scr'], 'filter_screener': [u'screener|scr'], 'filter_3d': [u'3d'], 'filter_telesync': [u'telesync|ts|tc'], 'filter_cam': [u'cam|hd\-?cam'], 'filter_tvrip': [u'tv\-?rip|sat\-?rip|dvb'], 'filter_vhsrip': [u'vhs\-?rip'], 'filter_iptvrip': [u'iptv\-?rip'], 'filter_trailer': [u'trailer|трейлер|тизер'], 'filter_workprint': [u'workprint'], 'filter_line': [u'line'] } # TODO: remove when finished with debugging resolutions detection # self.release_types = { # 'filter_brrip': ['brrip', 'bdrip', 'bd-rip', 'bluray', 'blu-ray', 'bdremux', 'bd-remux'], # 'filter_webdl': ['webdl', 'webrip', 'web-rip', 'web_dl', 'dlrip', '_yts_'], # 'filter_hdrip': ['hdrip', 'hd-rip'], # 'filter_hdtv': ['hdtv'], # 'filter_dvd': ['_dvd_', 'dvdrip', 'dvd-rip', 'vcdrip'], # 'filter_dvdscr': ['dvdscr', 'dvd-scr'], # 'filter_screener': ['screener', '_scr_'], # 'filter_3d': ['_3d_'], # 'filter_telesync': ['telesync', '_ts_', '_tc_'], # 'filter_cam': ['_cam_', 'hdcam'], # 'filter_tvrip': ['_tvrip', 'satrip'], # 'filter_vhsrip': ['vhsrip'], # 'filter_trailer': ['trailer', u'трейлер', u'тизер'], # 'filter_workprint': ['workprint'] # } require = [] resolutions_allow = [] releases_allow = [] releases_deny = [] for resolution in self.resolutions: if get_setting(resolution, bool): resolutions_allow.append(resolution) # Add enabled resolutions to allowed release types to match # previous versions' behavior with certain providers # with no release types in torrent names, ie. YTS releases_allow.extend(self.resolutions[resolution]) self.resolutions_allow = resolutions_allow # Skip resolution filtering if we're allowing all of them anyway self.filter_resolutions = True if len(self.resolutions_allow) == len(self.resolutions): self.filter_resolutions = False for release_type in self.release_types: if get_setting(release_type, bool): releases_allow.extend(self.release_types[release_type]) else: releases_deny.extend(self.release_types[release_type]) self.releases_allow = releases_allow self.releases_deny = releases_deny if get_setting('additional_filters', bool): accept = get_setting('accept', unicode).strip().lower() if accept: accept = re.split(r',\s?', accept) releases_allow.extend(accept) block = get_setting('block', unicode).strip().lower() if block: block = re.split(r',\s?', block) releases_deny.extend(block) require = get_setting('require', unicode).strip().lower() if require: require = re.split(r',\s?', require) self.require_keywords = require self.min_size = get_float(get_setting('min_size')) self.max_size = get_float(get_setting('max_size')) self.check_sizes() self.filter_title = False self.queries = [] self.extras = [] self.info = dict(title="", proxy_url="", internal_proxy_url="", elementum_url="", titles=[]) self.kodi_language = '' self.language_exceptions = [] self.get_data = {} self.post_data = {} self.url = '' self.title = '' self.reason = '' self.results = []
# Prompt the user for a number and a tolerance and calculate the number's # square root to the tolerance (accuracy) specified, using the Newton-Raphson # iteration method (not by importing math and using math.sqrt!). import math import utils def root(n, delta): xold = n/2.0 xnew = (n/xold+xold)/2.0 while math.fabs(xold-xnew) >= delta: xold = xnew xnew = (n/xold+xold)/2.0 return round(xnew, 3) #works print root(utils.get_int("Number to factor: ", "That's not int"), utils.get_float("Tolerance: ", "That's not float" )) #utils.get_float("Tolerance: ", "That's not float"))