def __init__(self, server):
'''
Init the Api with Ice objects created.
'''
FS.Api.__init__(self)
self.server = server
self.manager = ApiManager(server)
class Monitor(threading.Thread):
def __init__(self, config):
threading.Thread.__init__(self)
self._intersec = 1
self._thread_stop = False
self._monitor = None
new_gm_uid = config.generate_new_gm_uid()
self._device_model = config.device_model
self._api_mgr = ApiManager(new_gm_uid, config.attached_client_uid)
self.setup_descriptors()
if self._platform == common.PLATFORM_IOS:
self._monitor = iOSMonitor(self._device_descriptor,
self._app_descriptor)
elif self._platform == common.PLATFORM_ANDROID:
self._monitor = androidMonitor(self._device_descriptor,
self._app_descriptor)
self.setup_log()
def setup_descriptors(self):
self._platform = common.descriptors[self._device_model]['platform']
self._device_descriptor = \
common.descriptors[self._device_model]['device_descriptor'] or ''
self._app_descriptor = \
common.descriptors[self._device_model]['app_descriptor'] or ''
def setup_log(self):
log_file = 'profile-{model}.log'.format(model=self._device_model)
log_path = os.path.join(util.LOG_PATH, log_file)
file_handler = logging.FileHandler(log_path)
formatter = logging.Formatter('%(asctime)s-%(levelname)s: %(message)s',
datefmt='%H:%M:%S')
file_handler.setFormatter(formatter)
self._log = logging.getLogger('monitor_' + self._device_model)
self._log.addHandler(file_handler)
def run(self):
while not self._thread_stop:
if not self._monitor:
self._log.info(
'Here should be some data, but you dont have a monitor..')
else:
render_fps = self._api_mgr.to_exec(
'profiling.get_render_rate()')
memory = self._monitor.memory()
VSS = memory['VSS']
RSS = memory['RSS']
self._log.info('cpu usage:{cpu}, VSS:{VSS},' \
'RSS:{RSS}, fps:{render_fps}'.format(
cpu=self._monitor.cpu(), VSS=VSS, RSS=RSS,
render_fps=render_fps))
time.sleep(self._intersec)
def stop(self):
self._thread_stop = True
time.sleep(1)
self._api_mgr.disconnect()
def __init__(self, server):
"""
Init the Api with Ice objects created.
"""
FS.Api.__init__(self)
self.server = server
self.manager = ApiManager(server)
def try_fill_cell(csv_file, ids, break_after=None):
i = 0
if break_after:
ids = ids[0:break_after]
with ApiManager() as manager:
videos = manager.get_videos(ids)
with open(csv_file, errors='ignore') as csv_in:
header = csv_in.readline()
with open(os.path.join('out', csv_file), 'w',
errors='ignore') as csv_out:
csv_out.write(header)
for row in csv_in.readlines():
try:
video = videos[row.split(';')[0]]
row_to_write = str(video) + '\n'
except Exception as e:
row_to_write = [r for r in row.split(';')]
row_to_write[14] = 'True'
row_to_write = ';'.join(row_to_write)
print(e)
csv_out.write(row_to_write)
i += 1
if break_after and i == break_after:
break
def __init__(self, config):
threading.Thread.__init__(self)
self._intersec = 1
self._thread_stop = False
self._monitor = None
new_gm_uid = config.generate_new_gm_uid()
self._device_model = config.device_model
self._api_mgr = ApiManager(new_gm_uid, config.attached_client_uid)
self.setup_descriptors()
if self._platform == common.PLATFORM_IOS:
self._monitor = iOSMonitor(self._device_descriptor,
self._app_descriptor)
elif self._platform == common.PLATFORM_ANDROID:
self._monitor = androidMonitor(self._device_descriptor,
self._app_descriptor)
self.setup_log()
def __init__(self, config):
self.config = config
self.logger.set_level(self.config['log_level'])
self.population_size = self.config['population_size']
self.population = self.generate_initial_population()
# Initialize api manager -- maybe by reference in the future O:
self.api_manager = ApiManager(config)
# Warmup API Manager
while not self.api_manager.is_warm:
sleep(1)
else:
self.logger.progress('API Manager is warm')
# Housekeeping for later
self.population_first_frame_price = None
def start(self):
self.insta_manager = InstaManager(self.login, self.password)
self.api_manager = ApiManager()
self.follow_manager = FollowManager(self.login, self.password)
self.pic_manager = PicManager(self.login, self.password)
self.api_manager.start()
self.user_id = self.api_manager.get_user_id()
def main():
"""
Main part
"""
### Create Databases and tables ###
cnx = mysql.connector.connect(user=USER, password=PASSWORD,host=HOST)
cursor = cnx.cursor()
create_db(cursor, cnx)
populate_tables(cursor)
### Fetch the data from the API ###
api_manager = ApiManager()
categories = api_manager.categories()
for category in categories:
if category['products'] > MIN_PRODUCTS_PER_CATEGORY:
### Category ###
cursor.execute("INSERT INTO `category` (name, url, tag) VALUES (%s, %s, %s)"
,(category['name'], category['url'], category['id']))
category_index = cursor.lastrowid
print("Category added ")
cnx.commit()
### Products ###
products = api_manager.category_products(category['id'])
for product in products:
try:
print(product['product_name'])
cursor.execute("INSERT INTO `product` (name, description, stores, grade, link, fat, sugars, salt, saturated_fat) \
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)", (product['product_name'], product['generic_name_fr'], product['stores'], \
product['nutrition_grades'], product['link'], product['nutrient_levels']['fat'], product['nutrient_levels']['sugars'], \
product['nutrient_levels']['salt'], product['nutrient_levels']['saturated-fat']))
product_index = cursor.lastrowid
except KeyError:
pass
print("Product added ")
cnx.commit()
### Mutual table ###
cursor.execute("INSERT INTO `categories_products` (category_id, product_id) \
VALUES (%s, %s)", (category_index, product_index))
def system_update():
try:
flog("SYSTEM UPDATE")
key = request.form['key']
am = ApiManager(key)
token = am.get_token()
xml = am.get_products_by_dispensary(token, '684')
# write xml string in latest.xml
f = open('latest.xml', 'w')
f.write('%s' % xml)
f.close()
except Exception as exp:
print('system_update() :: Got exp: %s' % exp)
flog('system update failed')
return 'api key: % s' % key
def get_not_trendings(csv_file, region='GB', limit=10, limit_trendings=None):
# Get trendings to find date range
trendings, trending_ids = get_trendings(csv_file)
found_videos = []
i = 0
with ApiManager() as manager:
for trending_key, trending_value in trendings.items():
videos = manager.search_videos(trending_value.get_latest_video(), trending_value.get_oldest_video(), region, limit)
found_videos = found_videos + videos
i += 1
if limit_trendings and i > limit_trendings:
break
# Remove videos, that are on "trending" list
ids = [video.video_id for video in found_videos if video.video_id not in trending_ids]
# Remove duplicates
ids = list(set(ids))
not_trendings = manager.get_videos(ids)
return not_trendings
class PopulationManager:
@logged_initializer
def __init__(self, config):
self.config = config
self.logger.set_level(self.config['log_level'])
self.population_size = self.config['population_size']
self.population = self.generate_initial_population()
# Initialize api manager -- maybe by reference in the future O:
self.api_manager = ApiManager(config)
# Warmup API Manager
while not self.api_manager.is_warm:
sleep(1)
else:
self.logger.progress('API Manager is warm')
# Housekeeping for later
self.population_first_frame_price = None
# self.catchup_population()
def get_terminal(self):
terminal_to_create = choice(self.config['terminals'])
if terminal_to_create.type == 'constant':
terminal_value = uniform(*self.config['constants_range'])
elif terminal_to_create.type == 'run_time_evaluated':
FrameKeyPair = namedtuple('FrameKeyPair', 'frame key')
frame = randint(0, self.config['frames'] - 1)
terminal_value = FrameKeyPair(frame, terminal_to_create.value)
else:
terminal_value = terminal_to_create.value
return TerminalNode(terminal_to_create.type, terminal_value)
def get_function_node(self, depth, max_depth):
function_type = choice(self.config['node_functions'])
argument_count = randint(function_type.min_arity,
function_type.max_arity)
if depth == max_depth:
function_nodes = [
self.get_terminal() for _ in range(argument_count)
]
else:
function_nodes = []
for _ in range(argument_count):
function_selection_roll = random()
if function_selection_roll < self.config[
'function_selection_chance']:
function_nodes.append(
self.get_function_node(depth + 1, max_depth))
else:
function_nodes.append(self.get_terminal())
return FunctionNode(function_type, function_nodes) \
if depth != 0 else RootNode(function_type, function_nodes)
@logged_class_function
def generate_initial_population(self):
population = []
trees_to_generate = self.config['population_size']
depth = 1
next_step_trees = math.floor(trees_to_generate / 2)
while next_step_trees >= 1:
for _ in range(next_step_trees):
population.append(self.get_function_node(0, depth))
trees_to_generate -= next_step_trees
next_step_trees = math.floor(trees_to_generate / 2)
depth += 1
return population
@logged_class_function
def generate_next_generation(self, window):
def get_weighted_random_index():
random_int_range = (self.population_size /
2) * (self.population_size + 1)
random_choice = randint(0, random_int_range)
b = 2 * self.population_size + 1
random_index = math.floor(
(-b + math.sqrt(b**2 - 8 * random_choice)) / (-2))
return random_index
# In this step, get fitness alongside the sort
# sorted_fitness_index_pairs = self.sort_population_with_fitness(window)
self.sort_population(window)
# Okay here we go
next_population = []
# Take an amount of elites
elites = 10
elites_from_last_generation = self.population[:elites]
next_population.extend(elites_from_last_generation)
trees_from_last_generation_count = round(
self.config['replacement'] * self.population_size) - elites
# Positionally weighted reselection
for _ in range(trees_from_last_generation_count):
try:
index = get_weighted_random_index()
next_population.append(self.population[index])
except IndexError:
print(f'Index error, tried to select index: {index}')
next_population.append(self.population[-1])
# Recombination
trees_to_recombine = round(self.config['recombination'] *
self.population_size)
def get_all_function_nodes(tree, nodes=None):
if type(tree) == TerminalNode:
return
elif nodes is None:
nodes = [tree]
for node in tree.child_nodes:
if type(node) == FunctionNode:
nodes.append(node)
get_all_function_nodes(node, nodes)
return nodes
def get_all_nodes(tree, nodes=None):
if nodes is None:
nodes = [tree]
for node in tree.child_nodes:
if type(node) == FunctionNode:
nodes.append(node)
get_all_nodes(node, nodes)
elif type(node) == TerminalNode:
nodes.append(node)
return nodes
for _ in range(trees_to_recombine):
# Select parents
try:
index = get_weighted_random_index()
parent_1 = deepcopy(self.population[index])
except IndexError:
print(f'Index error, tried to select index: {index}')
parent_1 = deepcopy(self.population[-1])
try:
index = get_weighted_random_index()
parent_2 = deepcopy(self.population[index])
except IndexError:
print(f'Index error, tried to select index: {index}')
parent_2 = deepcopy(self.population[-1])
# Get all nodes
parent_1_function_nodes = get_all_function_nodes(parent_1)
parent_2_nodes = get_all_nodes(parent_2)
# Select recombination point from parent 1
parent_1_recombination_point = choice(parent_1_function_nodes)
parent_2_recombination_point = choice(parent_2_nodes)
# Combine trees
replacement_index = randint(
0,
len(parent_1_recombination_point.child_nodes) - 1)
parent_1_recombination_point.child_nodes[
replacement_index] = parent_2_recombination_point
# Add to list of trees
recombined_tree = parent_1
next_population.append(recombined_tree)
trees_to_mutate = round(self.population_size * self.config['mutation'])
for _ in range(trees_to_mutate):
tree_to_mutate = deepcopy(
self.population[get_weighted_random_index()])
parent_mutation_node = choice(
get_all_function_nodes(tree_to_mutate))
mutation_index = randint(0,
len(parent_mutation_node.child_nodes) - 1)
new_node = self.get_function_node(3, 4)
parent_mutation_node.child_nodes[mutation_index] = new_node
next_population.append(tree_to_mutate)
leftover_trees = self.population_size - len(next_population)
# Just take more copies of elites to fill the gap
next_population.extend(self.population[:leftover_trees])
# Housekeeping
[tree.reset_cash() for tree in next_population]
self.population_first_frame_price = None
self.population = next_population
@logged_class_function
def sort_population(self, window):
initial_buyable_asset = self.config[
'starting_value'] / self.population_first_frame_price
initial_bought_value_asset = initial_buyable_asset * window[0]['price']
self.population.sort(key=lambda tree: get_tree_fitness(
tree, window, initial_bought_value_asset),
reverse=True)
# def sort_population_with_fitness(self, window):
# fitnesses_with_index = [(get_tree_fitness(tree, window, initial_bought_value_asset), index) for index, tree in enumerate(self.population)]
# fitnesses_with_index.sort(key=lambda fitness_index: fitness_index[0], reverse=True)
# return fitnesses_with_index
@logged_class_function
def get_best_candidate(self, window):
self.sort_population(window)
return self.population[0]
@logged_class_function
def do_trades(self, window):
if self.population_first_frame_price is None:
self.population_first_frame_price = window[0]['price']
for tree in self.population:
decision = tree.get_decision(window)
tree.dollar_count -= decision
tree.asset_count += decision * window[0]['dollar_to_asset_ratio']
@logged_class_function
def get_population_statistics(self, window):
statistics = {
'average_value':
sum([score_tree(tree, window)
for tree in self.population]) / len(self.population),
'values': [(index, tree.last_ev)
for index, tree in enumerate(self.population)],
'cash_on_hand': [(index, tree.dollar_count)
for index, tree in enumerate(self.population)],
'asset_on_hand': [(index, tree.asset_count)
for index, tree in enumerate(self.population)],
'current_btc_price':
window[0]['price']
}
initial_buyable_asset = self.config[
'starting_value'] / self.population_first_frame_price
initial_bought_value_asset = initial_buyable_asset * window[0]['price']
statistics['normalized_average_value'] = statistics[
'average_value'] / initial_bought_value_asset
statistics['normalized_values'] = [
(index, value / initial_bought_value_asset)
for index, value in statistics['values']
]
return statistics
def train(self):
# Setup stat saving
os.umask(0)
run_path = f"run_stats/{self.config['run_id']}"
if not os.path.isdir(run_path):
os.mkdir(run_path)
for epoch in range(self.config['epochs']):
self.logger.progress(f'Starting Epoch {epoch}')
save_directory = f"{run_path}/epoch_{epoch}"
if not os.path.isdir(save_directory):
os.mkdir(save_directory, 0o777)
# Do catchup trades
catchup_trade_start_time = datetime.now()
catchup_window = self.api_manager.get_catchup_window()
for frame_index in range(self.config['frames']):
catchup_frame = catchup_window[self.config['frames'] -
frame_index:len(catchup_window
) - frame_index]
self.do_trades(catchup_frame)
stats = self.get_population_statistics(catchup_frame)
with open(f'{save_directory}/stats_{frame_index}.p',
'wb') as fp:
pickle.dump(stats, fp, protocol=pickle.HIGHEST_PROTOCOL)
catchup_trade_time_elapsed = (datetime.now() -
catchup_trade_start_time).seconds
self.logger.progress(
f"{catchup_trade_time_elapsed} seconds of catchup trades")
# Add in extra catchup frames from evaluation (recursively)
# Do live trades
time_elapsed = 0
window = None
while time_elapsed < self.config['seconds_before_evaluation']:
# log.info(f"Trading, time left: {config['seconds_before_evaluation'] - time_elapsed}")
trade_start_time = datetime.now()
window = self.api_manager.get_window()
self.do_trades(window)
stats = self.get_population_statistics(window)
# Save stats of the run
with open(
f'{save_directory}/stats_{time_elapsed + self.config["frames"]}.p',
'wb') as fp:
pickle.dump(stats, fp, protocol=pickle.HIGHEST_PROTOCOL)
# TODO On next frame from API manager
sleep(1)
time_elapsed += (datetime.now() - trade_start_time).seconds
self.logger.info(
f'Epoch_{epoch}: Time Elapsed: {time_elapsed}')
# Zip the epoch data
self.logger.info('Zipping stats')
output_filename = f"{run_path}/epoch_{epoch}_stats"
shutil.make_archive(output_filename, 'zip', save_directory)
# Unlink to save space
self.logger.info('Removing old stats')
shutil.rmtree(save_directory)
# log.debug('Generation average EV: ', population_manager.get_population_statistics()['average_value'])
self.logger.info('Generating next generation of trees')
self.generate_next_generation(window)
class Manager:
def __init__(self, login='******', password='******', category='brak', timestamp=3600):
self.login = login
self.password = password
self.users_to_like = []
self.category = category
self.timestamp = timestamp
def start(self):
self.insta_manager = InstaManager(self.login, self.password)
self.api_manager = ApiManager()
self.follow_manager = FollowManager(self.login, self.password)
self.pic_manager = PicManager(self.login, self.password)
self.api_manager.start()
self.user_id = self.api_manager.get_user_id()
def set_category(self, category):
self.category = category
self.pic_manager.category = category
def set_timestamp(self, timestamp):
tmp = self.timestamp * int(timestamp)
self.timestamp = tmp
# followuje uzytkownikow, ktorzy followali nas w czasie dzialania funkcji
# sleep_time - czas uspienia w sekundach.
def follow4follow(self, delay):
print("Follow4follow started...")
initial_count = int(self.api_manager.get_self_followed_by_count())
time.sleep(delay)
later_count = int(self.api_manager.get_self_followed_by_count())
if initial_count < later_count:
difference = later_count - initial_count
followers = self.follow_manager.get_followers(self.user_id)
while difference > 0:
self.insta_manager.follow(followers[difference - 1])
difference -= 1
# followuje wszystkich uzytkownikow z listy followersow
def alternative_follow4follow(self):
print("Follow4follow started...")
followers = self.follow_manager.get_followers(self.user_id)
for user in followers:
self.insta_manager.follow(user)
self.insta_manager.user_id = self.api_manager.id
# pobiera uzytkownikow, ktorzy like'owali nasze zdjecia
def get_users_to_like(self):
users = []
media = self.api_manager.get_user_self_media()
for i in media:
likers = self.follow_manager.get_media_likers(i)
for j in likers:
users.append(j)
return self.choose_users(users)
#wybiera 10 uzytkownikow do zalajkowania
def choose_users(self, users):
if users.__len__() < 10:
return users
else:
return random.sample(users, 10)
def like4like(self, users):
print ("Like4like started...")
for user in users:
user_name = self.follow_manager.get_user_name(user)
media_to_like = self.api_manager.get_user_media(user_name)
for media in media_to_like:
self.insta_manager.like(media)
def get_fame(self):
while (True):
print time.strftime("%c")
self.pic_manager.upload()
fame_tag_list = self.pic_manager.get_default_category_tags([])
print("Liking and following by fame tag list started...")
for tag in fame_tag_list[:3]:
self.insta_manager.get_media_id_by_tag(tag)
for media in self.insta_manager.media_by_tag:
self.insta_manager.like(media["id"])
self.insta_manager.follow(media["owner"]["id"])
self.alternative_follow4follow()
self.like4like(self.get_users_to_like())
timestamp = self.timestamp + random.randint(0,300)
print time.strftime("%c")
print ("Next getting fame after: "+str(timestamp)+ "sec")
time.sleep(timestamp)
from api_manager import ApiManager
from exceptions import *
InlineKeyboard = types.inline_keyboard.InlineKeyboardMarkup
InlineButton = types.inline_keyboard.InlineKeyboardButton
RemoveKeyboard = types.ReplyKeyboardRemove
ReplyKeyboard = types.ReplyKeyboardMarkup
ReplyButton = types.KeyboardButton
TOKEN = '699496323:AAHpHRNraSsW_DdZh4jNV518WDGglZKLaJY'
storage = MemoryStorage()
bot = Bot(TOKEN, parse_mode='Markdown', )
dp = Dispatcher(bot, storage=storage)
api = ApiManager()
class AuthForm(StatesGroup):
login = State()
password = State()
def start_filter(msg):
return msg.chat.type == 'private' and msg.text == '/start'
def menu_btn():
btn = ReplyKeyboard(resize_keyboard=True)
btn.insert('👤 Профиль')
return btn
class Api(FS.Api): # @UndefinedVariable
def __init__(self, server):
"""
Init the Api with Ice objects created.
"""
FS.Api.__init__(self)
self.server = server
self.manager = ApiManager(server)
def get_widgets(self):
pass
def getXMLWidgets(self, current=None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
return self.manager.generate_xml_widgets()
def version(self, current=None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
self.server.current_logger._print("Request hello")
self.server.current_logger.warning("Request hello")
self.server.current_logger.error("Request hello")
self.server.current_logger.trace("cat", "Request hello")
self.server.current_logger._print("Context counter:" + self.server.context.get("counter"))
self.server.current_logger._print("¡hello world!")
# http://doc.zeroc.com/display/Ice/Ice-Current
self.server.current_logger._print("Scan " + str(current))
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-adapter
print "Adapter", current.adapter.getName() # ::Ice::ObjectAdapter
# print dir(current.adapter)
print current.adapter.getCommunicator().getImplicitContext() # Ice::ImplicitContext
print current.adapter.getCommunicator().getDefaultRouter() # Ice::Router
# Ice::Locator* getDefaultLocator()
# Ice::PluginManager getPluginManager()
current.adapter.getCommunicator().flushBatchRequests()
# Ice::Context http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-ctx
print "Context:", current.ctx # http://doc.zeroc.com/display/Ice/Ice+Slice+API#IceSliceAPI-Context
print "Context:", current.ctx # http://doc.zeroc.com/display/Ice/Ice-ImplicitContext#Ice-ImplicitContext-getContext
print "Facet:", current.facet
# Ice::Identity http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-id
# http://doc.zeroc.com/display/Ice/Ice-Identity
print "Id name:", current.id.name
print "Id category:", current.id.category
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-mode
print "Mode:", current.mode #
# Ice::OperationMode http://doc.zeroc.com/display/Ice/Ice-OperationMode
print "Operation:", current.operation # scan # Ice.OperationMode.Normal
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-requestId
print "Request id:", current.requestId # oneway (0) or collocated (-1).
# http://doc.zeroc.com/display/Ice/Ice-Connection
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-con
connection = current.con # IcePy.Connection
connection.flushBatchRequests()
# local address = 79.143.179.118:10000
# remote address = 83.43.218.193:36806
# print 'String:', connection.toString()
print "End point:", connection.getEndpoint()
print "Timeout:", connection.timeout()
print "Type:", connection.type() # tcp or udp
info = connection.getInfo() # IcePy.TCPConnectionInfo
self.server.current_logger._print("Adapter name: " + str(info.adapterName))
self.server.current_logger._print("Incoming: " + str(info.incoming))
self.server.current_logger._print("Local address: " + str(info.localAddress))
self.server.current_logger._print("Local port: " + str(info.localPort))
self.server.current_logger._print("Remote address: " + str(info.remoteAddress))
self.server.current_logger._print("Remote port: " + str(info.remotePort))
force = False
connection.close(force)
version = "FS Server " + self.server.VERSION
print current
print version
return version
def getFile(self, current=None, path=None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
f = open("../test.tar.gz", "r")
data = f.read()
f.close()
return data
def getFileChunk(self, path=None, pos=0, size=0, current=None):
# Authentication could be enabled on each request, but slow down transfer
# self.manager.set_current(current)
# self.manager.check_authorized()
# self.manager.update_client_requests()
f = open("../" + str(path), "r") # Put absolute path on /
f.seek(int(pos), 0) # Seek absolute position
data = f.read(int(size))
f.close()
return data
def getFileSize(self, path=None, current=None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
file_size = os.path.getsize("../" + str(path)) # Put absolute path on /
return file_size
def isAuthorized(self, current=None):
self.manager.set_current(current)
result = self.manager.is_authorized()
# self.server.current_logger._print('Result isAuthorized: ' + str(result))
return result
def getClientId(self, current=None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
return self.manager.get_client_id()
class Api(FS.Api): #@UndefinedVariable
def __init__(self, server):
'''
Init the Api with Ice objects created.
'''
FS.Api.__init__(self)
self.server = server
self.manager = ApiManager(server)
def get_widgets(self):
pass
def getXMLWidgets(self, current = None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
return self.manager.generate_xml_widgets()
def version(self, current = None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
self.server.current_logger._print('Request hello')
self.server.current_logger.warning('Request hello')
self.server.current_logger.error('Request hello')
self.server.current_logger.trace('cat', 'Request hello')
self.server.current_logger._print('Context counter:' + self.server.context.get('counter'))
self.server.current_logger._print('¡hello world!')
# http://doc.zeroc.com/display/Ice/Ice-Current
self.server.current_logger._print('Scan ' + str(current))
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-adapter
print 'Adapter', current.adapter.getName() # ::Ice::ObjectAdapter
#print dir(current.adapter)
print current.adapter.getCommunicator().getImplicitContext() # Ice::ImplicitContext
print current.adapter.getCommunicator().getDefaultRouter() # Ice::Router
# Ice::Locator* getDefaultLocator()
# Ice::PluginManager getPluginManager()
current.adapter.getCommunicator().flushBatchRequests()
# Ice::Context http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-ctx
print 'Context:', current.ctx #http://doc.zeroc.com/display/Ice/Ice+Slice+API#IceSliceAPI-Context
print 'Context:', current.ctx #http://doc.zeroc.com/display/Ice/Ice-ImplicitContext#Ice-ImplicitContext-getContext
print 'Facet:', current.facet
# Ice::Identity http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-id
# http://doc.zeroc.com/display/Ice/Ice-Identity
print 'Id name:', current.id.name
print 'Id category:', current.id.category
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-mode
print 'Mode:', current.mode #
# Ice::OperationMode http://doc.zeroc.com/display/Ice/Ice-OperationMode
print 'Operation:', current.operation # scan # Ice.OperationMode.Normal
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-requestId
print 'Request id:', current.requestId # oneway (0) or collocated (-1).
# http://doc.zeroc.com/display/Ice/Ice-Connection
# http://doc.zeroc.com/display/Ice/Ice-Current#Ice-Current-con
connection = current.con # IcePy.Connection
connection.flushBatchRequests()
# local address = 79.143.179.118:10000
# remote address = 83.43.218.193:36806
#print 'String:', connection.toString()
print 'End point:', connection.getEndpoint()
print 'Timeout:', connection.timeout()
print 'Type:', connection.type() # tcp or udp
info = connection.getInfo() # IcePy.TCPConnectionInfo
self.server.current_logger._print('Adapter name: ' + str(info.adapterName))
self.server.current_logger._print('Incoming: ' + str(info.incoming))
self.server.current_logger._print('Local address: ' + str(info.localAddress))
self.server.current_logger._print('Local port: ' + str(info.localPort))
self.server.current_logger._print('Remote address: ' + str(info.remoteAddress))
self.server.current_logger._print('Remote port: ' + str(info.remotePort))
force = False
connection.close(force)
version = 'FS Server ' + self.server.VERSION
print current
print version
return version
def getFile(self, current = None, path = None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
f = open('../test.tar.gz', "r")
data = f.read()
f.close()
return data
def getFileChunk(self, path = None, pos = 0, size = 0, current = None):
# Authentication could be enabled on each request, but slow down transfer
#self.manager.set_current(current)
#self.manager.check_authorized()
#self.manager.update_client_requests()
f = open('../' + str(path), 'r') # Put absolute path on /
f.seek(int(pos), 0) # Seek absolute position
data = f.read(int(size))
f.close()
return data
def getFileSize(self, path = None, current = None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
file_size = os.path.getsize('../' + str(path)) # Put absolute path on /
return file_size
def isAuthorized(self, current = None):
self.manager.set_current(current)
result = self.manager.is_authorized()
#self.server.current_logger._print('Result isAuthorized: ' + str(result))
return result
def getClientId(self, current = None):
self.manager.set_current(current)
self.manager.check_authorized()
self.manager.update_client_requests()
return self.manager.get_client_id()
from bottle import route, post, request, hook, template, static_file
from instagram import client, subscriptions
from config import CONFIG, unauthenticated_api
from my_thread import MyThread
bottle.debug(True)
session_opts = {
'session.type': 'file',
'session.data_dir': './session/',
'session.auto': True,
}
app = beaker.middleware.SessionMiddleware(bottle.app(), session_opts)
pic_manager = PicManager()
api_manager = ApiManager()
@hook('before_request')
def setup_request():
request.session = request.environ['beaker.session']
def process_tag_update(update):
print(update)
@route('/static/<filepath:path>')
def server_static(filepath):
return static_file(filepath, root='./static')
