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"))
