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