def InitToolbar(self): toolbar = wx.ToolBar(self)#, style=wx.TB_NODIVIDER) tbBack = toolbar.AddLabelTool( wx.ID_ANY, 'Back', wx.Bitmap(Resource.GetFileName('arrow-left.png'))) self.Bind(wx.EVT_TOOL, self.OnBack, tbBack) self.tcPurchaseBillId = wx.TextCtrl(toolbar,size=wx.Size(80,-1)) self.tcPurchaseBillId.Bind(wx.EVT_KEY_UP, self.OnPurchaseBillId) toolbar.AddControl(self.tcPurchaseBillId) tbForward = toolbar.AddLabelTool( wx.ID_ANY, 'Forward', wx.Bitmap(Resource.GetFileName('arrow-right.png'))) self.Bind(wx.EVT_TOOL, self.OnForward, tbForward) toolbar.AddSeparator() tbSave = toolbar.AddLabelTool(wx.ID_ANY, 'Save', wx.Bitmap(Resource.GetFileName('save.png'))) self.Bind(wx.EVT_TOOL, self.OnSave, tbSave) tbAddRow = toolbar.AddLabelTool(wx.ID_ANY, 'Add Row', wx.Bitmap(Resource.GetFileName('add-row.png'))) self.Bind(wx.EVT_TOOL, self.OnAddRow, tbAddRow) tbPrint = toolbar.AddLabelTool( wx.ID_ANY, 'Print', wx.Bitmap(Resource.GetFileName('print.png'))) self.Bind(wx.EVT_TOOL, self.OnPrint, tbPrint) toolbar.Realize() self.toolbar = toolbar
def disconnect(self): try: if current_thread() is not self._thread: self._queue.push(exit) self._thread.join(3.0) finally: Resource.disconnect(self)
def Start(): # # make this plugin show up in the 'Video' section # # in Plex. The L() function pulls the string out of the strings # # file in the Contents/Strings/ folder in the bundle # # see also: # # http://dev.plexapp.com/docs/mod_Plugin.html # # http://dev.plexapp.com/docs/Bundle.html#the-strings-directory Plugin.AddPrefixHandler(VIDEO_PREFIX, MainMenu, NAME, ICON, ART) Plugin.AddViewGroup("InfoList", viewMode="InfoList", mediaType="items") Plugin.AddViewGroup("List", viewMode="List", mediaType="items") # # set some defaults so that you don't have to # # pass these parameters to these object types # # every single time # # see also: # # http://dev.plexapp.com/docs/Objects.html MediaContainer.title1 = NAME MediaContainer.viewGroup = "List" MediaContainer.art = Resource.Load(ART) DirectoryItem.thumb = Resource.Load(ICON) VideoItem.thumb = Resource.Load(ICON) HTTP.CacheTime = CACHE_1HOUR check_login_token()
def exit(self): import sys import Resource self.graph.destroy() self.application.root.destroy() self.application.root.quit() Resource.clean() sys.exit()
def saveFile(self): tags = self.getTags() #获取标签 for path in self.paths: Resource.uploadSaveBaseData(path, self.username, tags) #保存文件信息到数字资产库 #保存上传信息到用户信息库 self.saveFileInformationToUserdb(self.username, path)
def __init__(self, name, release): Resource.__init__(self, name) self._release = release self._ready, self._queue = Event(), InterlockedQueue() if __name__ == "__main__": self._timeout = Timeout(3.0) else: self._timeout = Timeout(60.0) self._count = 0
def Main(): f = None frame = None AdminShadow['admins'] = user.User() FirstUser['firstuser'] = user.User() threadddd['devicerequest'] = SendRequests.DeviceRequests() server = ServiceThread.Service() server.start() #add by wangderan start #thread = CheckHotplugDevice() #thread.start() #add by wangderan end #disaltl='xmodmap -e "keycode 64="' #disaltr='xmodmap -e "keycode 108="' os.system("service chronyd stop") os.system("chkconfig chronyd off") #os.system("%s"%disaltl) #os.system("%s"%disaltr) #Logger.info("Argbee Client start, version : %s", Version.string('python-hav-gclient', 3)) #Logger.info("Get Video Device : %s", " ".join(get_device())) #sleep(2) #os.system("%s"%disaltl) #os.system("%s"%disaltr) app = wx.PySimpleApp() area = wx.Display().GetGeometry() width = area.GetWidth() height = area.GetHeight() Resource.load(width, height) frame = LoginFrame.LoginFrame(None) frame.ShowFullScreen(True) ''' if autoLogin() : #f = MainFrame.MainFrame(frame, wx.ScreenDC().GetSize()) f = MainFrame.MainFrame(frame, (width, height)) f.Show(True) else : #frame.autoLogin() frame.ShowFullScreen(True) #Setting.save() #Logger.info( Setting.getIP() app.SetTopWindow(frame) ''' devicethread = threadddd.get("devicerequest", SendRequests.DeviceRequests()) devicethread.start() threadddd['devicerequest'] = devicethread app.MainLoop() Logger.info("Normal Exit")
def connect(self): Resource.connect(self) self._thread = LightThread(target=self._thread_proc, name="{0:s}:?".format(self.name)) self._thread.start() self._ready.wait( 3.0) # this may spend waiting slightly less, but it's ok if not self._ready.is_set(): self._queue.push( exit) # just in case the thread has in fact started raise Exception("new thread failed to start in 3.0 seconds")
def __init__(self): self.api_endpoint = self.API_ENDPOINT self.api_version = self.API_VERSION self.api_key = '' self.payments = Resource.Payments(self) self.payment_refunds = Resource.Refunds(self) self.issuers = Resource.Issuers(self) self.methods = Resource.Methods(self) self.version_strings = [] self.addVersionString('Mollie/' + self.CLIENT_VERSION) self.addVersionString('Python/' + sys.version.split(' ')[0]) self.addVersionString('OpenSSL/' + ssl.OPENSSL_VERSION.split(' ')[1])
def __init__(self): self.r1 = Resource("Coal", 40, 50, 50, 1, 1, 0) self.r2 = Resource("Wind/Solar", 90, 0, 30, 0, 1, 0) self.r3 = Resource("Nuclear", 70, 25, 40, 2, 1, 0) self.rl = [self.r1, self.r2, self.r3] self.total_pollution = 0 self.total_risk = 0 self.catastrophes = 0 self.gametime = 0 self.countries = [Country(25000, 1100, 1000), Country(10000, 300, 200)] self.Taxman = Taxman() self.threshold = 100000 self.global_collapse = False self.country_collapse = False self.currentResPrices = self.get_r_prices()
def system_init(): processor_temp = Processor() resource_temp = Resource() processor_temp.create_process('init', 0) for x in processor_temp.get_running_list(): print(x + " ", end='') return processor_temp, resource_temp
def __init__(self, prototype, fileName = None): """ @param prototype: The configuration protype mapping @param fileName: The file that holds this configuration registry """ self.prototype = prototype # read configuration self.config = MyConfigParser() if fileName: if not os.path.isfile(fileName): path = Resource.getWritableResourcePath() fileName = os.path.join(path, fileName) self.config.read(fileName) self.fileName = fileName # fix the defaults and non-existing keys for section, options in prototype.items(): if not self.config.has_section(section): self.config.add_section(section) for option in options.keys(): type = options[option].type default = options[option].default if not self.config.has_option(section, option): self.config.set(section, option, str(default))
def __init__(self, request, prepcache=True): "Determine and open cache location, get descriptor backend. " super(CachingProtocol, self).__init__() self.request = request # Track server response self.__status, self.__message = None, None if not prepcache: return self.cache = Resource.get_cache(request.hostinfo, request.envelope[1]) # Get descriptor storage reference self.descriptors = Resource.get_backend()
def nottest_func_get_size_for_dir_three_file(self): """ Test get size for empty directories. """ str_dir = os.path.join(self.str_test_directory, "test_func_get_size_for_dir_three_file") str_file_1 = os.path.join(self.str_test_directory, "test_func_get_size_for_dir_three_file", "file_one.txt") str_file_2 = os.path.join(self.str_test_directory, "test_func_get_size_for_dir_three_file", "file_two.txt") str_file_3 = os.path.join(self.str_test_directory, "test_func_get_size_for_dir_three_file", "file_three.txt") str_answer = "316.0 B" self.func_make_dummy_dir(self.str_test_directory) self.func_make_dummy_dir(str_dir) self.func_make_dummy_file(str_file_1, "File_one.txt") self.func_make_dummy_file(str_file_2, "File_two.txt") self.func_make_dummy_file(str_file_3, "File_three.txt") str_size = Resource.Resource(str_path=str_dir, f_is_product=True).func_get_size() self.func_remove_files([str_file_1, str_file_2, str_file_3]) self.func_remove_dirs([str_dir, self.str_test_directory]) self.func_test_equals(str_answer, str_size)
def __init__(self, prototype, fileName=None): """ @param prototype: The configuration protype mapping @param fileName: The file that holds this configuration registry """ self.prototype = prototype # read configuration self.config = MyConfigParser() if fileName: if not os.path.isfile(fileName): path = Resource.getWritableResourcePath() fileName = os.path.join(path, fileName) self.config.read(fileName) self.fileName = fileName # fix the defaults and non-existing keys for section, options in prototype.items(): if not self.config.has_section(section): self.config.add_section(section) for option in options.keys(): type = options[option].type default = options[option].default if not self.config.has_option(section, option): self.config.set(section, option, str(default))
def __handleInternalRequest(pathNouns, _path, **kwargs): # # Handle a request internally # if len(pathNouns) > 1: if pathNouns[1] == "resources": if len(pathNouns) == 3: ext = pathNouns[2][pathNouns[2].rfind("."):] PMS.Log("(Framework) Getting resource named '%s'" % pathNouns[2]) resource = Resource.Load(pathNouns[2]) return Objects.DataObject(resource, Resource.MimeTypeForExtension(ext)) if pathNouns[1] == "sharedresources": if len(pathNouns) == 3: ext = pathNouns[2][pathNouns[2].rfind("."):] PMS.Log("(Framework) Getting shared resource named '%s'" % pathNouns[2]) resource = Resource.LoadShared(pathNouns[2]) return Objects.DataObject(resource, Resource.MimeTypeForExtension(ext)) elif pathNouns[1] == "function" and len(pathNouns) >= 3: name = pathNouns[2] pos = name.rfind(".") if pos > -1: name = name[:pos] PMS.Log(name) if name not in __reservedFunctionNames: if len(pathNouns) == 4: kwargs['query'] = pathNouns[3] result = __callNamed(name, **kwargs) #PMS.Log(result) return result elif pathNouns[1] == "prefs": if len(pathNouns) == 2: return Prefs.__container() else: Prefs.__setAll(kwargs) result = __callNamed("ValidatePrefs", addToLog=False) if result: return result else: return ''
def __handleInternalRequest(pathNouns, path, **kwargs): # # Handle a request internally # if len(pathNouns) > 1: if pathNouns[1] == "resources": if len(pathNouns) == 3: if Resource.__publicResources.has_key(pathNouns[2]): PMS.Log("(Framework) Getting resource named '%s'" % pathNouns[2]) resource = Resource.Load(pathNouns[2]) return Objects.DataObject( resource, Resource.__publicResources[pathNouns[2]]) if pathNouns[1] == "sharedresources": if len(pathNouns) == 3: if Resource.__publicSharedResources.has_key(pathNouns[2]): PMS.Log("(Framework) Getting shared resource named '%s'" % pathNouns[2]) resource = Resource.LoadShared(pathNouns[2]) return Objects.DataObject( resource, Resource.__publicSharedResources[pathNouns[2]]) elif pathNouns[1] == "function" and len(pathNouns) >= 4: name = pathNouns[2] if name not in __reservedFunctionNames: encodedArgs = pathNouns[3] pos = encodedArgs.rfind(".") if pos > -1: encodedArgs = encodedArgs[:pos] fkwargs = pickle.loads(D(encodedArgs)) # Override encoded kwargs with kwargs passed in the URL for key in kwargs: fkwargs[key] = kwargs[key] if len(pathNouns) == 4: return __callNamed(name, **fkwargs) elif len(pathNouns) == 5: return __callNamed(name, query=pathNouns[4], **fkwargs) elif pathNouns[1] == "prefs": if len(pathNouns) == 2: return Prefs.__container() else: Prefs.__setAll(kwargs) return __callNamed("ValidatePrefs", addToLog=False)
def serve_descriptor(self, status, protocol, request): q = urlparse.urlparse( request.url[3] )[4] url = urlparse.urlparse(urllib.unquote(q[4:])) if ':' in url[1]: hostinfo = url[1].split(':') hostinfo[1] = int(hostinfo[1]) else: hostinfo = url[1], 80 cache = Resource.get_cache(hostinfo, url[2][1:]) descriptors = Resource.get_backend() if cache.path in descriptors: descr = descriptors[cache.path] self.prepare_response(status, Params.json_write(descr), mime='application/json') else: self.prepare_response("404 No Data", "No data for %s %s %s %s"%request.url)
def init(): pygame.init() #pygame初始化 pygame.mouse.set_visible(False) #隐藏鼠标 Et.game_state = GAMEINIT #初始化游戏状态 Et.R_if = Rs.RInterface("Resource/json/interface") #加载界面资源 Et.I_ctr = Ip.Control() #初始化键盘控制 Et.t_net = threading.Thread(target=host, args=()) t = threading.Thread(target=music, args=()) t.setDaemon(True) t.start()
def test_init_for_one_abs_path_product(self): """ Testing init for an absolute path. """ str_path_one = os.path.join(os.getcwd(), "This", "is", "a", "path1") str_answer = " ".join([ "PATH:", str_path_one + ",", "CLEAN:", str(Resource.CLEAN_DEFAULT) + ",", "Product", "PARENTS: [] CHILDREN: []" ]) rsc_test = Resource.Resource(str_path=str_path_one, f_is_product=True) str_result = str(rsc_test) self.func_test_equals(str_answer, str_result)
def build_gui(self, container): self.root = container qtwidget = QtGui.QWidget() self.resource = Resource.ResourceDisplay(qtwidget, logger=self.logger) layout = QtGui.QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(self.resource, stretch=1) container.setLayout(layout)
def test_func_is_dependency_clean_level_for_bad_case_none(self): """ Testing for indicating if the dependency is a certain clean level. Level = None """ str_path_one = os.path.join(os.path.sep, "This", "is", "a", "path1") rsc_test = Resource.Resource(str_path=str_path_one, f_is_product=True, i_clean=None) f_result = rsc_test.func_is_dependency_clean_level(None) f_answer = False self.func_test_equals(f_answer, f_result)
def test_init_for_one_relative_path_dependency(self): """ Testing init for updating relative path (dependency). """ str_path_one = os.path.join("This", "is", "a", "path1") str_answer = " ".join([ "PATH:", os.path.join(os.getcwd(), str_path_one) + ",", "CLEAN:", str(Resource.CLEAN_DEFAULT) + ",", "Dependency", "PARENTS: [] CHILDREN: []" ]) rsc_test = Resource.Resource(str_path=str_path_one, f_is_product=False) str_result = str(rsc_test) self.func_test_equals(str_answer, str_result)
def __init__(self, str_cur_command, lstr_cur_dependencies, lstr_cur_products, str_name="unnamed"): """ Initializer. All paths should be absolute paths. If given relative paths, the current working directory will be added on to the path to make the file path absolute. * str_cur_command : String Command to execute * lstr_cur_dependencies : List of strings List of absolute paths paths for dependencies * lstr_cur_products : List of strings List of absolute paths for products to be made """ # Set there id for the parent vertex Graph.Vertex.__init__(self, str_cur_command) self.str_type = STR_TYPE self.str_status = STR_NOT_RUN self.str_name = str_name for str_dependency in lstr_cur_dependencies: rsc_dep = Resource.Resource(str_dependency, f_is_product=False) self.func_add_parent(rsc_dep) rsc_dep.func_add_child(self) for str_product in lstr_cur_products: rsc_prod = Resource.Resource(str_product, f_is_product=True) self.func_add_child(rsc_prod) rsc_prod.func_add_parent(self) # Controls updating the commandlines pas flags # This often needs to be true when adding a sciedpiper script with # an update command. self.f_stop_update_at_flags = False
def _InitToolBar(self): toolbar = wx.ToolBar(self, style=wx.TB_NODIVIDER) tbNewInvoice = toolbar.AddLabelTool( wx.ID_ANY, 'New Invoice', wx.Bitmap(Resource.GetFileName('invoice-new.png'))) self.Bind(wx.EVT_TOOL, self.OnNewInvoice, tbNewInvoice) tbViewInvoice = toolbar.AddLabelTool( wx.ID_ANY, 'View Invoice', wx.Bitmap(Resource.GetFileName('invoice-view.png'))) self.Bind(wx.EVT_TOOL, self.OnViewInvoice, tbViewInvoice) toolbar.AddSeparator() tbPurchase = toolbar.AddLabelTool( wx.ID_ANY, 'Purchase Bill', wx.Bitmap(Resource.GetFileName('purchase-bill.png'))) self.Bind(wx.EVT_TOOL, self.OnPurchase, tbPurchase) toolbar.Realize() userbar = wx.ToolBar(self, style=wx.TB_NODIVIDER) tbLogOut = userbar.AddLabelTool( wx.ID_ANY, 'Quit', wx.Bitmap(Resource.GetFileName('exit.png'))) self.Bind(wx.EVT_TOOL, self.OnLogOut, tbLogOut) userbar.Realize() self.stUserName = wx.StaticText(self, label="") maintoolbar = wx.BoxSizer(wx.HORIZONTAL) maintoolbar.Add(toolbar, 1, wx.ALIGN_LEFT, 5) maintoolbar.Add(self.stUserName, 0, wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL, 5) maintoolbar.Add(userbar, 0, wx.ALIGN_RIGHT, 5) return maintoolbar
def nottest_func_get_size_for_empty_dir(self): """ Test get size for empty directories. """ str_dir = os.path.join(self.str_test_directory, "test_func_get_size_for_empty_dir") str_answer = "68.0 B" self.func_make_dummy_dir(self.str_test_directory) self.func_make_dummy_dir(str_dir) str_size = Resource.Resource(str_path=str_dir, f_is_product=True).func_get_size() self.func_remove_dirs([str_dir, self.str_test_directory]) self.func_test_equals(str_answer, str_size)
def match_templates(staff_img, staff, i, note_imgs_, note_lower_, note_upper_, note_thresh, notation, duration=0, rest=False): _boxes = Resource.locate_templates(staff_img, note_imgs_, note_lower_, note_upper_, note_thresh) _boxes = Resource.merge([j for i in _boxes for j in i], 0.5) for box in _boxes: box.draw(staff_img, (0, 0, 255), 1) text = f"{notation}" font = cv2.FONT_HERSHEY_DUPLEX textsize = cv2.getTextSize(text, font, fontScale=0.255, thickness=1)[0] x = int(box.getCorner()[0] - (textsize[0] // 2)) y = int(box.getCorner()[1] + box.getHeight() + 20) cv2.putText(staff_img, text, (x, y), font, fontScale=0.25, color=(0, 0, 255), thickness=1) y_center = box.getCenter() # print(f'x_center {int(round(y_center[0]))} y_center {int(round(y_center[1]))}') pitch = staff.get_pitch(int(round((y_center)[1]))) nimage = f'qnotes{i}.png' cv2.imwrite(nimage, staff_img) if (rest): obj = MusicObject(notation, 'rest', duration, box, pitch) else: obj = MusicObject(notation, 'note', duration, box, pitch) if (notation == 'sharp' or notation == 'flat'): return sequence.append(obj)
def test_init_for_clean_1(self): """ Testing init for cleaning level 1. """ str_path_one = os.path.join(os.getcwd(), "This", "is", "a", "path1") str_answer = " ".join([ "PATH:", str_path_one + ",", "CLEAN:", str(Resource.CLEAN_NEVER) + ",", "Product", "PARENTS: [] CHILDREN: []" ]) rsc_test = Resource.Resource(str_path=str_path_one, f_is_product=True, i_clean=Resource.CLEAN_NEVER) str_result = str(rsc_test) self.func_test_equals(str_answer, str_result)
def find_cleff(staff_img, i, clef_imgs, clef_lower, clef_upper, clef_thresh): for clef in clef_imgs: # print("Matching {} clef template on staff".format(clef), i + 1) clef_boxes = Resource.locate_templates(staff_img, clef_imgs[clef], clef_lower, clef_upper, clef_thresh) clef_boxes = Resource.merge([j for i in clef_boxes for j in i], 0.5) if (len(clef_boxes) == 1): print("Clef Found: ", clef) staffs[i].setClef(clef) # print("[INFO] Displaying Matching Results on staff", i + 1) clef_boxes_img = staffs[i].getImage() clef_boxes_img = clef_boxes_img.copy() for boxes in clef_boxes: boxes.draw(staff_img, (0, 255, 0), 1) x = int(boxes.getCorner()[0] + (boxes.getWidth() // 2)) y = int(boxes.getCorner()[1] + boxes.getHeight() + 10) cv2.putText(staff_img, "{} clef".format(clef), (x, y), cv2.FONT_HERSHEY_DUPLEX, 0.9, (0, 255, 0))
def test_func_is_dependency_clean_level_for_good_case_temp(self): """ Testing for indicating if the dependency is a certain clean level. Level = temp """ str_path_one = os.path.join(os.path.sep, "This", "is", "a", "path1") rsc_test = Resource.Resource(str_path=str_path_one, f_is_product=True, i_clean=Resource.CLEAN_AS_TEMP) f_result = rsc_test.func_is_dependency_clean_level( Resource.CLEAN_AS_TEMP) f_answer = True self.func_test_equals(f_answer, f_result)
def update(event): if Et.game_state == GAMEINIT: Et.R_if.screen.blit(Et.R_if.main_bk_pic, (0, 0)) mouseResponseGameInit(event) buttonShow() cursorShow() elif Et.game_state == GAMESETTING: Et.R_if.screen.blit(Et.R_if.main_bk_pic, (0, 0)) mouseResponseGameSetting(event) settingShow() cursorShow() elif Et.game_state == GAMEHELP: Et.R_if.screen.blit(Et.R_if.main_bk_pic, (0, 0)) mouseResponseGameHelp(event) helpShow() cursorShow() elif Et.game_state == GAMEINIT1: cursorShow() Et.R_gc = Rs.RChoose(game_file[0]) Et.game_state = GAMESINGLECHOOSE elif Et.game_state == GAMESINGLECHOOSE: Et.R_if.screen.blit(Et.R_gc.bottom_pic, (0, 0)) mouseResponseGameSingleChoose(event) singleChooseShow() cursorShow() elif Et.game_state == GAMELOADSUB: Et.R_pl = Rs.RCharacter(Et.R_gc.character_file[Et.player_choice]) Et.R_em = Rs.REnemy(enemy_file[Et.game_choice]) Et.R_ob = Rs.RObstacle(obstacle_file[Et.game_choice]) for i in range(0, 3): Et.R_sk[i] = Rs.RSkill(skill_file[Et.R_pl.skill[i]]) Et.R_sg = Rs.RSingle(game_file[1][Et.game_choice]) Et.game_state = GAMELOAD elif Et.game_state == GAMELOAD: Et.game_state = GAMESTART elif Et.game_state == GAMESTART: Et.I_ctr.update() gameBlit() #test_case.test() elif Et.game_state == GAMEONLINEINIT1: Et.R_pl = Rs.RCharacter(character_file[Et.player_choice]) Et.R_sg = Rs.RSingle(game_file[1][Et.game_choice]) Et.game_state = GAMEONLINEINIT2 elif Et.game_state == GAMEONLINEINIT2: Et.game_state = GAMEONLINE elif Et.game_state == GAMEONLINE: Et.I_ctr.update() onlineBlit()
def updateStatus(self): self.files = [] states = 'modified added removed deleted unknown ignored clean'.split() self.repository = hg.repository(ui.ui(), self.directory) status = self.repository.status('.', None, None, True, True, True) self.changestates = zip(states, status) for _state, _files in self.changestates: for _file in _files: resource = Resource() resource.setPath(_file) resource.setState(NSLocalizedString(_state, None)) resource.setSelected(False) self.files.append(resource)
Config.define("player", "leftymode", int, 0, text = _("Lefty Mode"), options = {0: _("Off"), 1: _("On")}) Config.define("player", "drumflip", int, 0, text = _("Drum Flip"), options = {0: _("Off"), 1: _("On")}) Config.define("player", "two_chord_max", int, 0, text = _("Two-Chord Max"), options = {0: _("Off"), 1: _("On")}) Config.define("player", "assist_mode", int, 0, text = _("Assist Mode"), options = {0: _("Off"), 1: _("Easy Assist"), 2: _("Medium Assist")}) Config.define("player", "auto_kick", int, 0, text = _("Auto Kick"), options = {0: _("Off"), 1: _("On")}) Config.define("player", "controller", int, 0) controlpath = os.path.join("data","users","controllers") playerpath = os.path.join("data","users","players") if not hasattr(sys,"frozen"): controlpath = os.path.join("..",controlpath) playerpath = os.path.join("..",playerpath) #stump: permission fix for read-only system-wide installation if not os.path.isfile(os.path.join(playerpath, 'FoFiX-players.cache')): baseuserpath = os.path.join(Resource.getWritableResourcePath(), 'users') newcontrolpath = os.path.join(baseuserpath, 'controllers') newplayerpath = os.path.join(baseuserpath, 'players') for old, new in [(controlpath, newcontrolpath), (playerpath, newplayerpath)]: if not os.path.isdir(new): os.makedirs(new) for f in os.listdir(old): shutil.copy(os.path.join(old, f), os.path.join(new, f)) controlpath = newcontrolpath playerpath = newplayerpath control0 = None control1 = None control2 = None control3 = None controlDict = {}
def debugOut(self, engine): try: f = open("debug.log", "w+") except IOError: # fallback for unix (games dir read-only) import Resource # evilynux - Under MacOS X, put the logs in ~/Library/Logs if( os.uname()[0] == "Darwin" ): logFile = open(os.path.join(Resource.getWritableResourcePath(), "..", "..", "Logs", Version.appName(), "debug.log"), "w+") else: # GNU/Linux et al. f = open(os.path.join(Resource.getWritableResourcePath(), 'debug.log'), "w+") version = Version.version() currentDir = os.getcwd() dataDir = Version.dataPath() translationDir = dataDir + "/translations" modsDir = dataDir + "/mods" f.write("Date = %s\n" % datetime.datetime.now()) f.write("\nVersion = %s\n" % version) f.write("\nOS = %s\n" % os.name) f.write("\nCurrent Directory = %s\n" % currentDir) self.directoryList(f, currentDir) f.write("\nData Directory = %s\n" % dataDir) self.directoryList(f, dataDir) zip_path = os.path.join(dataDir, 'library.zip') # no library.zip on regular unix installation if os.path.exists(zip_path): f.write("\nLibrary.zip\n") zip = zipfile.ZipFile(zip_path, 'r') for info in zip.infolist(): fileName = info.filename fileCSize = info.compress_size fileSize = info.file_size fileDate = datetime.datetime(*(info.date_time)) f.write("%s, %s, %s, %s\n" % (fileName, fileCSize, fileSize, fileDate)) f.write("\nTranslation Directory = %s\n" % translationDir) self.directoryList(f, translationDir) f.write("\nMods Directory = %s\n" % modsDir) self.directoryList(f, modsDir) mods = os.listdir(modsDir) for mod in mods: modDir = os.path.join(modsDir, mod) if os.path.isdir(modDir): f.write("\nMod Directory = %s\n" % modDir) self.directoryList(f, modDir) f.write("\nFretsonfire.ini\n") engine.config.config.write(f) # No write() in Theme #f.write("\nTheme.ini\n") #Theme.write(f, engine.config) f.write("\nStage.ini\n") stage = Stage.Stage(self, self.engine.resource.fileName("stage.ini")) stage.config.write(f) f.close()
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this program; if not, write to the Free Software # # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # # MA 02110-1301, USA. # ##################################################################### import sys import os import Resource quiet = True if os.name == "posix": # evilynux - logfile in ~/.fretsonfire/ for GNU/Linux and MacOS X logFile = open(os.path.join(Resource.getWritableResourcePath(), "fretsonfire.log"), "w") else: logFile = open("fretsonfire.log", "w") #MFH - local logfile! encoding = "iso-8859-1" if "-v" in sys.argv: quiet = False if os.name == "posix": labels = { "warn": "\033[1;33m(W)\033[0m", "debug": "\033[1;34m(D)\033[0m", "notice": "\033[1;32m(N)\033[0m", "error": "\033[1;31m(E)\033[0m", }
def main(): playing = None configFile = None fullscreen = None resolution = None theme = None #debug = False difficulty = None part = None mode = 0 nbrplayers = 1 for opt, arg in opts: if opt in ["--verbose", "-v"]: Log.quiet = False if opt in ["--config", "-c"]: configFile = arg if opt in ["--fullscreen", "-f"]: fullscreen = arg if opt in ["--resolution", "-r"]: resolution = arg if opt in ["--theme", "-t"]: theme = arg if opt in ["--song", "-s"]: playing = arg if opt in ["--part", "-p"]: part = arg if opt in ["--diff", "-d", "-l"]: difficulty = arg #evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-n"]: nbrplayers = int(arg) # Load the configuration file. if configFile is not None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.PROGRAM_UNIXSTYLE_NAME + ".ini") os.remove(fileName) config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True) else: config = Config.load(configFile, setAsDefault = True) else: config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True) #Lysdestic - Allow support for manipulating fullscreen via CLI if fullscreen is not None: Config.set("video", "fullscreen", fullscreen) #Lysdestic - Change resolution from CLI if resolution is not None: Config.set("video", "resolution", resolution) #Lysdestic - Alter theme from CLI if theme is not None: Config.set("coffee", "themename", theme) engine = GameEngine(config) engine.cmdPlay = 0 # Check for a valid invocation of one-shot mode. if playing is not None: Log.debug('Validating song directory for one-shot mode.') library = Config.get("game","base_library") basefolder = os.path.join(Version.dataPath(),library,"songs",playing) if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))): Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing) engine.startupMessages.append(_("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode.") % playing) playing = None # Set up one-shot mode if the invocation is valid for it. if playing is not None: Log.debug('Entering one-shot mode.') Config.set("game", "selected_library", "songs") Config.set("game", "selected_song", playing) engine.cmdPlay = 1 if difficulty is not None: engine.cmdDiff = int(difficulty) if part is not None: engine.cmdPart = int(part) #evilynux - Multiplayer and mode selection support if nbrplayers == 1: engine.cmdMode = nbrplayers, mode, 0 else: engine.cmdMode = nbrplayers, 0, mode encoding = Config.get("game", "encoding") if encoding is not None: #stump: XXX: Everything I have seen indicates that this is a # horrible, horrible hack. Is there another way? Do we even need this? reload(sys) sys.setdefaultencoding(encoding) # Play the intro video if it is present, we have the capability, and # we are not in one-shot mode. videoLayer = False if videoAvailable and not engine.cmdPlay: # TODO: Parameters to add to theme.ini: # - intro_video_file # - intro_video_start_time # - intro_video_end_time themename = Config.get("coffee", "themename") vidSource = os.path.join(Version.dataPath(), 'themes', themename, \ 'menu', 'intro.mp4') if os.path.isfile(vidSource): winWidth, winHeight = engine.view.geometry[2:4] songVideoStartTime = 0 songVideoEndTime = None vidPlayer = VideoPlayer(-1, vidSource, (winWidth, winHeight), startTime = songVideoStartTime, endTime = songVideoEndTime) if vidPlayer.validFile: engine.view.pushLayer(vidPlayer) videoLayer = True try: engine.ticksAtStart = pygame.time.get_ticks() while not vidPlayer.finished: engine.run() engine.view.popLayer(vidPlayer) engine.view.pushLayer(MainMenu(engine)) except KeyboardInterrupt: engine.view.popLayer(vidPlayer) engine.view.pushLayer(MainMenu(engine)) if not videoLayer: engine.setStartupLayer(MainMenu(engine)) #stump: make psyco optional if Config.get("performance", "use_psyco"): try: import psyco psyco.profile() except: Log.error("Unable to enable psyco as requested: ") # Run the main game loop. try: engine.ticksAtStart = pygame.time.get_ticks() while engine.run(): pass except KeyboardInterrupt: Log.notice("Left mainloop due to KeyboardInterrupt.") # don't reraise # Restart the program if the engine is asking that we do so. if engine.restartRequested: Log.notice("Restarting.") engine.audio.close() try: # Extra arguments to insert between the executable we call and our # command line arguments. args = [] # Figure out what executable to call. if hasattr(sys, "frozen"): if os.name == "nt": # When py2exe'd, sys.executable is the name of the EXE. exe = os.path.abspath(unicode(sys.executable, sys.getfilesystemencoding())) elif sys.frozen == "macosx_app": # When py2app'd, sys.executable is a Python interpreter copied # into the same dir where we live. exe = os.path.join(os.path.dirname(sys.executable), 'FoFiX') # FIXME: don't hard-code "FoFiX" here else: raise RuntimeError, "Don't know how to restart when sys.frozen is %s" % repr(sys.frozen) else: # When running from source, sys.executable is the Python interpreter # being used to run the program. exe = sys.executable # Pass the optimization level on iif python version >= 2.6.0 as # sys.flags has been introduced in 2.6.0. if sys.version_info[:3] >= (2,6,0) and sys.flags.optimize > 0: args.append('-%s' % ('O' * sys.flags.optimize)) args.append(sys.argv[0]) os.execv(exe, [sys.executable] + args + sys.argv[1:]) except: Log.error("Restart failed: ") raise # evilynux - MainMenu class already calls this - useless? engine.quit()
def main(self): logging.info("Incubator started... " + self.start_time.strftime('%Y-%m-%d %H:%M:%S')) self.send_notification("Incubator started") self.ssr.set_point(self.config.get_temp()) # Start roller self.roller.set_day(self.config.get_day()) self.roller.start() web = Web.Web(self) web.start() lcd = Lcd() temp_sensor = Resource.create_temp_sensor() htu21d = Resource.create_humidity_sensor() # Start SSR service self.ssr.set_value(0) self.ssr.start() # Start buttons and relays # self.io_handler.start() i = 0 state = State() state.set_day(self.get_days_from_start()) http_sender = HttpSender.HttpSender() while self._running: state.update_ts() state.set_temp1(temp_sensor.read_temp()) pid = self.ssr.update(state.get_temp1()) state.set_pid(pid) #if state.temp1 > 38.5: # self.send_notification("High temp alert, {} gr".format(state.temp1)) if i % 10 == 0: # Read humidity and temp each 10 seconds try: state.set_temp2(htu21d.read_temperature()) state.set_humidity(htu21d.read_humidity()) except: self.send_notification("Failed to read htu21d") self.ventilation.set_state(state) state.set_humidity_level(self.ventilation.get_output_level()) http_sender.send("A123", state) if i >= 30: # Set new temp from config file self.config.reload() self.ssr.set_point(self.config.get_temp()) self.ssr.set_k(self.config.get_k()) self.ssr.set_i(self.config.get_i()) self.ventilation.set_point(self.get_humidity()) state.set_day(self.get_days_from_start()) if self.config.get_day() != state.get_day(): self.config.set_day(state.get_day()) self.config.save() self.roller.set_day(state.get_day()) self.log_incubator_state(self.config, state) # update web page web.update(state, self.config) i = 0 lcd.update(state, self.roller.get_minutes_from_last_roll()) sys.stdout.flush() time.sleep(1) i += 1 self.shutdown()
def main(self): # TODO Load the map blocked need map object # init turns # TODO self.initializePlayerTurns() for player in reversed(self.players): while len(player.get_PowerPlants()) == 0: auction = Auction.Auction( self.Table.getDeck(), self.Table.getCardsForAuction() + self.Table.getFutureCardsForAuction() ) # TODO Anandh add auction stuff while not self.gameover: print("buy resources") # PHASE 2 bid for resources for player in self.players: request = {} request[Resource.COAL] = player.getCoalRequest() request[Resource.OIL] = player.getOilRequest() request[Resource.GARBAGE] = player.getGarbageRequest() request[Resource.URANIUM] = player.getUraniumRequest() cost = Resource.buy_resource(request) if cost == 0: player.warn(NOT_ENOUGH_RESOURCES) elif cost <= player.f_b_get_money(): player.pay(cost) player.add_coal(request[Resource.COAL]) player.add_oil(request[Resource.OIL]) player.add_garbage(request[Resource.GARBAGE]) player.add_uranium(request[Resource.URANIUM]) else: # This case there is not enough money player.warn(NOT_ENOUGH_MONEY) self.ResourceMarket.restore_resources() # PHASE 3 buy cities # TODO Blocked no map available # PHASE 4 power cities for player in self.players: player.powerCities() # TODO check game end # PHASE 5 pay the players for player in self.players: player.addMoney(payday.pay(player.get_cities_powered)) # Check if advance to 2 if self.currentPhase == 1: self.checkAdvancePhaseTwo() for player in self.players: if player.get_cities() >= self.GAMEEND[self.numPlayers]: self.gameover = True # PHASE 1 bid for power plants self.players = calculateTurns() availableCards = self.Table.getCardsForAuction() futureCards = self.Table.getFutureCardsForAuction() self.checkAdvancePhaseThree(availableCards) # Pass to players # TODO Auction print("Bid for power plants") auction = Auction.Auction(self.Table.getDeck(), availableCards + futureCards)
if opt in ["--song", "-s"]: playing = arg if opt in ["--part", "-p"]: part = arg if opt in ["--diff", "-d", "-l"]: difficulty = arg #evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-n"]: nbrplayers = int(arg) # Load the configuration file. if configFile is not None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.PROGRAM_UNIXSTYLE_NAME + ".ini") os.remove(fileName) config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True) else: config = Config.load(configFile, setAsDefault = True) else: config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True) #Lysdestic - Allow support for manipulating fullscreen via CLI if fullscreen is not None: Config.set("video", "fullscreen", fullscreen) #Lysdestic - Change resolution from CLI if resolution is not None: Config.set("video", "resolution", resolution)
import sys import os import Resource import Version import traceback import time import warnings ## Whether to output log entries to stdout in addition to the logfile. quiet = True ## File object representing the logfile. if os.name == "posix": # evilynux - logfile in ~/.fofix/ for GNU/Linux and MacOS X # evilynux - Under MacOS X, put the logs in ~/Library/Logs if os.uname()[0] == "Darwin": logFile = open(os.path.join(Resource.getWritableResourcePath(), "..", "..", "Logs", Version.appName() + ".log"), "w") else: # GNU/Linux et al. logFile = open(os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".log"), "w") else: logFile = open(Version.appName() + ".log", "w") #MFH - local logfile! ## Character encoding to use for logging. encoding = "iso-8859-1" if "-v" in sys.argv or "--verbose" in sys.argv: quiet = False ## Labels for different priorities, as output to the logfile. labels = {
if opt in ["--play", "-p"]: playing = arg if opt in ["--diff", "-D"]: difficulty = arg if opt in ["--part", "-P"]: part = arg # evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-N"]: nbrplayers = int(arg) while True: if configFile != None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini") os.remove(fileName) config = Config.load(Version.appName() + ".ini", setAsDefault=True) else: config = Config.load(configFile, setAsDefault=True) else: config = Config.load(Version.appName() + ".ini", setAsDefault=True) engine = GameEngine(config) engine.cmdPlay = 0 if playing != None: Config.set("game", "selected_library", "songs") Config.set("game", "selected_song", playing) engine.cmdPlay = 1 engine.cmdDiff = int(difficulty) engine.cmdPart = int(part)
## core.py## Copyright (C) 2009 John Doee <*****@*****.**>## Basic plugin template created by:# Copyright (C) 2008 Martijn Voncken <*****@*****.**># Copyright (C) 2007-2009 Andrew Resch <*****@*****.**># Copyright (C) 2009 Damien Churchill <*****@*****.**>## Deluge is free software.## You may redistribute it and/or modify it under the terms of the# GNU General Public License, as published by the Free Software# Foundation; either version 3 of the License, or (at your option)# any later version.## deluge is distributed in the hope that it will be useful,# but WITHOUT ANY WARRANTY; without even the implied warranty of# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.# See the GNU General Public License for more details.## You should have received a copy of the GNU General Public License# along with deluge. If not, write to:# The Free Software Foundation, Inc.,# 51 Franklin Street, Fifth Floor# Boston, MA 02110-1301, USA.## In addition, as a special exception, the copyright holders give# permission to link the code of portions of this program with the OpenSSL# library.# You must obey the GNU General Public License in all respects for all of# the code used other than OpenSSL. If you modify file(s) with this# exception, you may extend this exception to your version of the file(s),# but you are not obligated to do so. If you do not wish to do so, delete# this exception statement from your version. If you delete this exception# statement from all source files in the program, then also delete it here.# import base64import jsonimport loggingimport osimport urllib import deluge.configmanager from collections import defaultdict from deluge import componentfrom deluge._libtorrent import ltfrom deluge.core.rpcserver import exportfrom deluge.plugins.pluginbase import CorePluginBase from twisted.internet import reactor, defer, taskfrom twisted.python import randbytesfrom twisted.web import server, resource, static, http, client from .filelike import FilelikeObjectResourcefrom .resource import Resource logger = logging.getLogger(__name__) DEFAULT_PREFS = { 'ip': '127.0.0.1', 'port': 46123, 'allow_remote': False, 'reset_complete': True, 'use_stream_urls': True, 'auto_open_stream_urls': False, 'remote_username': '******', 'remote_password': '******',} def sleep(seconds): d = defer.Deferred() reactor.callLater(seconds, d.callback, seconds) return d class FileServeResource(resource.Resource): isLeaf = True def __init__(self): self.file_mapping = {} resource.Resource.__init__(self) def generate_secure_token(self): return base64.urlsafe_b64encode(randbytes.RandomFactory().secureRandom(21, True)) def add_file(self, path): token = self.generate_secure_token() self.file_mapping[token] = path return token def render_GET(self, request): key = request.path.split('/')[2] if key not in self.file_mapping: return resource.NoResource().render(request) f = self.file_mapping[key] if f.is_complete(): return static.File(f.full_path).render_GET(request) else: tfr = f.open() return FilelikeObjectResource(tfr, f.size).render_GET(request) class StreamResource(Resource): isLeaf = True def __init__(self, client, *args, **kwargs): self.client = client Resource.__init__(self, *args, **kwargs) @defer.inlineCallbacks def render_GET(self, request): infohash = request.args.get('infohash', None) path = request.args.get('path', None) if infohash is None: defer.returnValue(json.dumps({'status': 'error', 'message': 'missing infohash'})) if path is None: defer.returnValue(json.dumps({'status': 'error', 'message': 'missing path'})) result = yield self.client.stream_torrent(infohash[0], path[0]) defer.returnValue(json.dumps(result)) class UnknownTorrentException(Exception): pass class UnknownFileException(Exception): pass class TorrentFileReader(object): def __init__(self, torrent_file): self.torrent_file = torrent_file self.size = torrent_file.size self.position = 0 self.waiting_for_piece = None self.current_piece = None self.current_piece_data = None @defer.inlineCallbacks def read(self, size=1024): required_piece, read_position = self.torrent_file.get_piece_info(self.position) if self.current_piece != required_piece: logger.debug('We are missing piece %i and it is required, requesting' % (required_piece, )) self.waiting_for_piece = required_piece self.current_piece_data = yield self.torrent_file.get_piece_data(required_piece) self.current_piece = required_piece self.waiting_for_piece = None logger.debug('We can read from local piece from %s size %s from position %s' % (read_position, size, self.position)) data = self.current_piece_data[read_position:read_position+size] self.position += len(data) defer.returnValue(data) def tell(self): return self.position def close(self): self.torrent_file.close(self) def seek(self, offset, whence=os.SEEK_SET): self.position = offset class TorrentFile(object): # can be read from, knows about itself def __init__(self, torrent, first_piece, last_piece, piece_size, offset, path, full_path, size, index): self.torrent = torrent self.first_piece = first_piece self.last_piece = last_piece self.piece_size = piece_size self.offset = offset self.path = path self.size = size self.full_path = full_path self.index = index self.file_requested = False self.do_shutdown = False self.first_piece_end = self.piece_size * (self.first_piece + 1) - offset self.waiting_pieces = {} self.current_readers = [] self.registered_alert = False self.alerts = component.get("AlertManager") def open(self): """ Returns a filelike object """ if not self.registered_alert: self.alerts.register_handler("read_piece_alert", self.on_alert_got_piece_data) self.registered_alert = True tfr = TorrentFileReader(self) self.current_readers.append(tfr) self.file_requested = False return tfr def close(self, tfr): self.current_readers.remove(tfr) self.torrent.unprioritize_pieces(tfr) def is_complete(self): torrent_status = self.torrent.torrent.get_status(['file_progress', 'state']) file_progress = torrent_status['file_progress'] return file_progress[self.index] == 1.0 def get_piece_info(self, tell): return divmod((self.offset + tell), self.piece_size) def on_alert_got_piece_data(self, alert): torrent_id = str(alert.handle.info_hash()) if torrent_id != self.torrent.infohash: return logger.debug('Got piece data for piece %s' % alert.piece) if alert.piece not in self.waiting_pieces: logger.debug('Got data for piece %i, but no data needed for this piece?' % alert.piece) return # TODO: check piece size is not zero self.waiting_pieces[alert.piece].callback(alert.buffer) @defer.inlineCallbacks def get_piece_data(self, piece): logger.debug('Trying to get piece data for piece %s' % piece) for reader in self.current_readers: if reader.current_piece == piece: defer.returnValue(reader.current_piece_data) if piece not in self.waiting_pieces: self.waiting_pieces[piece] = defer.Deferred() logger.debug('Waiting for %s' % piece) self.torrent.schedule_piece(self, piece, 0) while not self.torrent.torrent.handle.have_piece(piece): if self.do_shutdown: raise Exception() logger.debug('Did not have piece %i, waiting' % piece) self.torrent.unrelease() yield sleep(1) self.torrent.torrent.handle.read_piece(piece) data = yield self.waiting_pieces[piece] if piece in self.waiting_pieces: del self.waiting_pieces[piece] logger.debug('Done waiting for piece %i, returning data' % piece) defer.returnValue(data) def shutdown(self): self.do_shutdown = True class Torrent(object): def __init__(self, torrent_handler, infohash): self.infohash = infohash self.torrent = component.get("TorrentManager").torrents.get(infohash, None) self.torrent_handler = torrent_handler if not self.torrent: raise UnknownTorrentException('%s is not a known infohash' % infohash) self.torrent_files = None self.priority_increased = defaultdict(set) self.do_shutdown = False self.torrent_released = True # set to True if all the files are set to download self.populate_files() self.file_priorities = [0] * len(self.torrent_files) self.last_piece = self.torrent_files[-1].last_piece self.torrent.handle.set_sequential_download(True) reactor.callLater(0, self.update_piece_priority) reactor.callLater(0, self.blackhole_all_pieces, 0, self.last_piece) def populate_files(self): self.torrent_files = [] status = self.torrent.get_status(['piece_length', 'files', 'save_path']) piece_length = status['piece_length'] files = status['files'] save_path = status['save_path'] for f in files: first_piece = f['offset'] / piece_length last_piece = (f['offset'] + f['size']) / piece_length full_path = os.path.join(save_path, f['path']) self.torrent_files.append(TorrentFile(self, first_piece, last_piece, piece_length, f['offset'], f['path'], full_path, f['size'], f['index'])) return files def find_file(self, file_or_index=None, includes_name=False): best_file = None biggest_file_size = 0 for i, f in enumerate(self.torrent_files): path = f.path if not includes_name and '/' in path: path = '/'.join(path.split('/')[1:]) logger.debug('Testing file %r against %s / %r' % (file_or_index, i, path)) if file_or_index is not None: if i == file_or_index or path == file_or_index: best_file = f break else: if f.size > biggest_file_size: best_file = f biggest_file_size = f.size return best_file def get_file(self, file_or_index=None, includes_name=False): f = self.find_file(file_or_index, includes_name) if f is None: raise UnknownFileException('Was unable to find %s' % file_or_index) return f def unprioritize_pieces(self, tfr): logger.debug('Unprioritizing pieces for %s' % tfr) currently_downloading = self.get_currently_downloading() for piece, increased_by in self.priority_increased.items(): if tfr in increased_by: increased_by.remove(tfr) if not increased_by and piece not in currently_downloading and not self.torrent.status.pieces[piece]: logger.debug('Unprioritizing piece %s' % piece) self.torrent.handle.piece_priority(piece, 0) def get_currently_downloading(self): currently_downloading = set() for peer in self.torrent.handle.get_peer_info(): if peer.downloading_piece_index != -1: currently_downloading.add(peer.downloading_piece_index) return currently_downloading def blackhole_all_pieces(self, first_piece, last_piece): currently_downloading = self.get_currently_downloading() logger.debug('Blacklisting pieces from %i to %i skipping %r' % (first_piece, last_piece, currently_downloading)) for piece in range(first_piece, last_piece+1): if piece not in currently_downloading and not self.torrent.status.pieces[piece]: if piece in self.priority_increased: continue logger.debug('Setting piece priority %s to blacklist' % piece) self.torrent.handle.piece_priority(piece, 0) def unrelease(self): if self.torrent_released: logger.debug('Unreleasing %s' % self.infohash) self.torrent_released = False self.torrent.set_file_priorities(self.file_priorities) self.blackhole_all_pieces(0, self.last_piece) def get_torrent_file(self, file_or_index, includes_name): f = self.get_file(file_or_index, includes_name) f.file_requested = True self.torrent.resume() should_update_priorities = False if self.file_priorities[f.index] == 0: self.file_priorities[f.index] = 3 should_update_priorities = True if self.torrent_released: should_update_priorities = True if should_update_priorities and not f.is_complete(): # Need to do this stuff on seek too self.unrelease() return f def shutdown(self): logger.info('Shutting down torrent %s' % self.infohash) self.do_shutdown = True for tf in self.torrent_files: tf.shutdown() def schedule_piece(self, torrent_file, piece, distance): if torrent_file not in self.priority_increased[piece]: if not self.priority_increased[piece]: self.priority_increased[piece].add(torrent_file) logger.debug('Scheduled piece %s at distance %s' % (piece, distance)) self.torrent.handle.piece_priority(piece, (7 if distance <= 4 else 6)) self.torrent.handle.set_piece_deadline(piece, 700*(distance+1)) self.priority_increased[piece].add(torrent_file) def do_pieces_schedule(self, torrent_file, currently_downloading, from_piece): logger.debug('Looking for stuff to do with pieces for file %s from piece %s' % (torrent_file, from_piece)) priority_increased = 0 chain_size = 0 download_chain_size = 0 end_of_chain = False current_buffer_offset = 5 if self.torrent.status.pieces[torrent_file.last_piece]: if torrent_file.first_piece != torrent_file.last_piece and self.torrent.status.pieces[torrent_file.last_piece-1] \ or torrent_file.first_piece == torrent_file.last_piece: current_buffer_offset = 20 for piece, status in enumerate(self.torrent.status.pieces[from_piece:torrent_file.last_piece+1], from_piece): if not end_of_chain: if status: chain_size += 1 elif piece in currently_downloading: download_chain_size += 1 if not status and piece not in currently_downloading: if not end_of_chain: status_increase = max(11, chain_size-current_buffer_offset) end_of_chain = True priority_increased += 1 if priority_increased >= status_increase: logger.debug('Done increasing priority for %i pieces' % status_increase) break self.schedule_piece(torrent_file, piece, piece-from_piece) else: logger.info('We are done with the rest of this chain, we might be able to increase others') return True return False def update_piece_priority(self): # if all do_pieces_schedule returns true, allow all pices of file to be downloaded or whole torernt if self.do_shutdown: return logger.debug('Updating piece priority for %s' % self.infohash) currently_downloading = set() for peer in self.torrent.handle.get_peer_info(): if peer.downloading_piece_index != -1: currently_downloading.add(peer.downloading_piece_index) all_heads_done = True for f in self.torrent_files: if not f.file_requested and not f.current_readers: continue logger.debug('Rescheduling file %s' % f.path) if f.file_requested: all_heads_done &= self.do_pieces_schedule(f, currently_downloading, f.first_piece) self.schedule_piece(f, f.last_piece, 0) if f.first_piece != f.last_piece: self.schedule_piece(f, f.last_piece-1, 1) for tfr in f.current_readers: if tfr.waiting_for_piece is not None: logger.debug('Scheduling based on waiting for piece %s' % tfr.waiting_for_piece) all_heads_done &= self.do_pieces_schedule(f, currently_downloading, tfr.waiting_for_piece) elif tfr.current_piece is not None: logger.debug('Scheduling based on current piece %s' % tfr.current_piece) all_heads_done &= self.do_pieces_schedule(f, currently_downloading, tfr.current_piece) if all(self.torrent.status.pieces): logger.debug('All pieces complete, no need to loop') return if all_heads_done and not self.torrent_released: logger.debug('We are already done with all heads, figuring out what to do next') if self.torrent_handler.config['reset_complete']: self.torrent_released = True logger.debug('Resetting all disabled files') file_priorities = [(1 if fp == 0 else fp) for fp in self.file_priorities] self.torrent.set_file_priorities(file_priorities) if not all_heads_done and self.torrent_released: logger.debug('Seems like the torrent was released too early') self.unrelease() reactor.callLater(0.3, self.update_piece_priority) class TorrentHandler(object): def __init__(self, config): self.torrents = {} self.config = config self.alerts = component.get("AlertManager") self.alerts.register_handler("torrent_removed_alert", self.on_alert_torrent_removed) def get_stream(self, infohash, file_or_index=None, includes_name=False): logger.info('Trying to stream infohash %s and file %s include_name %s' % (infohash, file_or_index, includes_name)) if infohash not in self.torrents: self.torrents[infohash] = Torrent(self, infohash) return self.torrents[infohash].get_torrent_file(file_or_index, includes_name) def on_alert_torrent_removed(self, alert): try: torrent_id = str(alert.handle.info_hash()) except (RuntimeError, KeyError): logger.warning('Failed to handle on torrent remove alert') return if torrent_id not in self.torrents: return self.torrents[torrent_id].shutdown() del self.torrents[torrent_id] def shutdown(self): logger.debug('Shutting down TorrentHandler') self.alerts.deregister_handler(self.on_alert_torrent_removed) for torrent in self.torrents.values(): torrent.shutdown() class Core(CorePluginBase): def enable(self): self.config = deluge.configmanager.ConfigManager("streaming.conf", DEFAULT_PREFS) self.fsr = FileServeResource() self.resource = Resource() self.resource.putChild('file', self.fsr) if self.config['allow_remote']: self.resource.putChild('stream', StreamResource(username=self.config['remote_username'], password=self.config['remote_password'], client=self)) self.site = server.Site(self.resource) try: session = component.get("Core").session settings = session.get_settings() settings['prioritize_partial_pieces'] = True session.set_settings(settings) except AttributeError: logger.warning('Unable to exclude partial pieces') self.torrent_handler = TorrentHandler(self.config) try: self.listening = reactor.listenTCP(self.config['port'], self.site, interface=self.config['ip']) except: self.listening = reactor.listenTCP(self.config['port'], self.site, interface='0.0.0.0') @defer.inlineCallbacks def disable(self): self.site.stopFactory() self.torrent_handler.shutdown() yield self.listening.stopListening() def update(self): pass @export @defer.inlineCallbacks def set_config(self, config): """Sets the config dictionary""" for key in config.keys(): self.config[key] = config[key] self.config.save() yield self.disable() self.enable() @export def get_config(self): """Returns the config dictionary""" return self.config.config @export @defer.inlineCallbacks def stream_torrent(self, infohash=None, url=None, filedump=None, filepath_or_index=None, includes_name=False): tor = component.get("TorrentManager").torrents.get(infohash, None) if tor is None: logger.info('Did not find torrent, must add it') if not filedump and url: filedump = yield client.getPage(url) if not filedump: defer.returnValue({'status': 'error', 'message': 'unable to find torrent, provide infohash, url or filedump'}) torrent_info = lt.torrent_info(lt.bdecode(filedump)) infohash = str(torrent_info.info_hash()) core = component.get("Core") try: yield core.add_torrent_file('file.torrent', filedump.encode('base64'), {'add_paused': True}) except: defer.returnValue({'status': 'error', 'message': 'failed to add torrent'}) try: tf = self.torrent_handler.get_stream(infohash, filepath_or_index, includes_name) except UnknownTorrentException: defer.returnValue({'status': 'error', 'message': 'unable to find torrent, probably failed to add it'}) defer.returnValue({ 'status': 'success', 'use_stream_urls': self.config['use_stream_urls'], 'auto_open_stream_urls': self.config['auto_open_stream_urls'], 'url': 'http://%s:%s/file/%s/%s' % (self.config.config['ip'], self.config.config['port'], self.fsr.add_file(tf), urllib.quote_plus(os.path.basename(tf.path).encode('utf-8'))) })
def main(): playing = None configFile = None fullscreen = None resolution = None x = None y = None theme = None debug = False difficulty = None part = None mode = 0 nbrplayers = 1 for opt, arg in opts: if opt in ["--verbose", "-v"]: Log.quiet = False if opt in ["--debug", "-d"]: debug = True if opt in ["--config", "-c"]: configFile = arg if opt in ["--fullscreen", "-f"]: fullscreen = arg if opt in ["--resolution", "-r"]: resolution = arg if opt in ["--geometry", "-g"]: r = re.match('([0-9]+x\d+)\+?(\d+)?\+?(\d+)?',arg) print "geometry tested ",arg (resolution,x,y) = r.groups() print "found ",resolution," x ",x," y ",y if opt in ["--theme", "-t"]: theme = arg if opt in ["--song", "-s"]: playing = arg if opt in ["--diff", "-l"]: difficulty = arg if opt in ["--part", "-p"]: part = arg #evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-n"]: nbrplayers = int(arg) # Load the configuration file. if configFile is not None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini") os.remove(fileName) config = Config.load(Version.appName() + ".ini", setAsDefault = True) else: config = Config.load(configFile, setAsDefault = True) else: config = Config.load(Version.appName() + ".ini", setAsDefault = True) #Lysdestic - Allow support for manipulating fullscreen via CLI if fullscreen is not None: Config.set("video", "fullscreen", fullscreen) #Lysdestic - Change resolution from CLI if resolution is not None: Config.set("video", "resolution", resolution) if x is not None: Config.set("video", "x", x) Config.set("video","fullscreen",False) if y is not None: Config.set("video", "y", y) Config.set("video","fullscreen",False) #Lysdestic - Alter theme from CLI if theme is not None: Config.set("coffee", "themename", theme) engine = GameEngine(config) engine.cmdPlay = 0 # Check for a valid invocation of one-shot mode. if playing is not None: Log.debug('Validating song directory for one-shot mode.') library = Config.get("game","base_library") basefolder = os.path.join(Version.dataPath(),library,"songs",playing) if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))): Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing) engine.startupMessages.append(_("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode.") % playing) playing = None # Set up one-shot mode if the invocation is valid for it. if playing is not None: Log.debug('Entering one-shot mode.') Config.set("game", "selected_library", "songs") Config.set("game", "selected_song", playing) engine.cmdPlay = 1 if difficulty is not None: engine.cmdDiff = int(difficulty) if part is not None: engine.cmdPart = int(part) #evilynux - Multiplayer and mode selection support Config.set("game", "players", nbrplayers) if nbrplayers == 1: Config.set("game", "game_mode", mode) else: Config.set("game", "game_mode", 0) Config.set("game", "multiplayer_mode", mode) if debug: engine.setDebugModeEnabled(not engine.isDebugModeEnabled()) engine.debugLayer.debugOut(engine) engine.quit() return encoding = Config.get("game", "encoding") if encoding is not None: #stump: XXX: Everything I have seen indicates that this is a # horrible, horrible hack. Is there another way? Do we even need this? reload(sys) sys.setdefaultencoding(encoding) engine.setStartupLayer(MainMenu(engine)) #stump: make psyco optional if Config.get("performance", "use_psyco"): try: import psyco psyco.profile() except: Log.error("Unable to enable psyco as requested: ") # Run the main game loop. try: engine.ticksAtStart = pygame.time.get_ticks() while engine.run(): pass except KeyboardInterrupt: Log.notice("Left mainloop due to KeyboardInterrupt.") # don't reraise # Restart the program if the engine is asking that we do so. if engine.restartRequested: Log.notice("Restarting.") engine.audio.close() try: # Extra arguments to insert between the executable we call and our # command line arguments. args = [] # Figure out what executable to call. if hasattr(sys, "frozen"): if os.name == "nt": # When py2exe'd, sys.executable is the name of the EXE. exe = os.path.abspath(unicode(sys.executable, sys.getfilesystemencoding())) elif sys.frozen == "macosx_app": # When py2app'd, sys.executable is a Python interpreter copied # into the same dir where we live. exe = os.path.join(os.path.dirname(sys.executable), 'FoFiX') # FIXME: don't hard-code "FoFiX" here else: raise RuntimeError, "Don't know how to restart when sys.frozen is %s" % repr(sys.frozen) else: # When running from source, sys.executable is the Python interpreter # being used to run the program. exe = sys.executable # Pass the optimization level on. if sys.flags.optimize > 0: args.append('-%s' % ('O' * sys.flags.optimize)) args.append(__file__) os.execv(exe, [sys.executable] + args + sys.argv[1:]) except: Log.error("Restart failed: ") raise # evilynux - MainMenu class already calls this - useless? engine.quit()
import sys import os import Resource import Version import traceback import time import warnings ## Whether to output log entries to stdout in addition to the logfile. quiet = True ## File object representing the logfile. if os.name == "posix": # evilynux - logfile in ~/.fofix/ for GNU/Linux and MacOS X # evilynux - Under MacOS X, put the logs in ~/Library/Logs if os.uname()[0] == "Darwin": logFile = open(os.path.join(Resource.getWritableResourcePath(), "..", "..", "Logs", Version.PROGRAM_UNIXSTYLE_NAME + ".log"), "w") else: # GNU/Linux et al. logFile = open(os.path.join(Resource.getWritableResourcePath(), Version.PROGRAM_UNIXSTYLE_NAME + ".log"), "w") else: logFile = open(Version.PROGRAM_UNIXSTYLE_NAME + ".log", "w") #MFH - local logfile! ## Character encoding to use for logging. encoding = "iso-8859-1" if "-v" in sys.argv or "--verbose" in sys.argv: quiet = False ## Labels for different priorities, as output to the logfile. labels = {
def main(): """Main thread""" try: opts, args = getopt.getopt(sys.argv[1:], "vdc:f:r:t:s:l:p:m:n:", ["verbose", "debug", "config=", "fullscreen=", "resolution=", "theme=", "song=", "diff=", "part=", "mode=", "nbrplayers="]) except getopt.GetoptError: print usage sys.exit(1) playing = None configFile = None fullscreen = None resolution = None theme = None debug = False difficulty = None part = None mode = 0 nbrplayers = 1 for opt, arg in opts: if opt in ["--verbose", "-v"]: Log.quiet = False if opt in ["--debug", "-d"]: debug = True if opt in ["--config", "-c"]: configFile = arg if opt in ["--fullscreen", "-f"]: fullscreen = arg if opt in ["--resolution", "-r"]: resolution = arg if opt in ["--theme", "-t"]: theme = arg if opt in ["--song", "-s"]: playing = arg if opt in ["--diff", "-l"]: difficulty = arg if opt in ["--part", "-p"]: part = arg #evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-n"]: nbrplayers = int(arg) while 1: if configFile != None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini") os.remove(fileName) config = Config.load(Version.appName() + ".ini", setAsDefault = True) else: config = Config.load(configFile, setAsDefault = True) else: config = Config.load(Version.appName() + ".ini", setAsDefault = True) #Lysdestic - Allow support for manipulating fullscreen via CLI if fullscreen != None: Config.set("video", "fullscreen", fullscreen) #Lysdestic - Change resolution from CLI if resolution != None: Config.set("video", "resolution", resolution) #Lysdestic - Alter theme from CLI if theme != None: Config.set("coffee", "themename", theme) if playing != None: library = Config.get("game","base_library") basefolder = os.path.join(Version.dataPath(),library,"songs",playing) if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))): Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing) playing = None engine = GameEngine(config) engine.cmdPlay = 0 if playing != None: Config.set("game", "selected_library", "songs") Config.set("game", "selected_song", playing) engine.cmdPlay = 1 if difficulty is not None: engine.cmdDiff = int(difficulty) if part is not None: engine.cmdPart = int(part) #evilynux - Multiplayer and mode selection support Config.set("game", "players", nbrplayers) if nbrplayers == 1: Config.set("game", "game_mode", mode) else: Config.set("game", "game_mode", 0) Config.set("game", "multiplayer_mode", mode) if debug == True: engine.setDebugModeEnabled(not engine.isDebugModeEnabled()) engine.debugLayer.debugOut(engine) engine.quit() break encoding = Config.get("game", "encoding") if encoding != None: reload(sys) sys.setdefaultencoding(encoding) engine.setStartupLayer(MainMenu(engine)) #stump: make psyco optional if Config.get("performance", "use_psyco"): try: import psyco psyco.profile() except: Log.warn("Unable to enable psyco.") try: engine.ticksAtStart = pygame.time.get_ticks() while engine.run(): pass except KeyboardInterrupt: pass if engine.restartRequested: Log.notice("Restarting.") engine.audio.close() try: # Determine whether were running from an exe or not if hasattr(sys, "frozen"): if os.name == "nt": os.execl("FoFiX.exe", "FoFiX.exe", *sys.argv[1:]) elif sys.frozen == "macosx_app": import string import subprocess appname = string.join(string.split(sys.executable, '/')[:-1], '/') appname = appname+"/FoFiX" subprocess.Popen(`appname`, shell=True) else: os.execl("./FoFiX", "./FoFiX", *sys.argv[1:]) else: # stump: sys.executable points to the active python interpreter os.execl(sys.executable, sys.executable, "FoFiX.py", *sys.argv[1:]) except: Log.warn("Restart failed.") raise break else: break # evilynux - MainMenu class already calls this - useless? engine.quit()
def main(): """Main thread""" try: opts, args = getopt.getopt(sys.argv[1:], "vdc:p:D:P:m:N:", ["verbose", "debug", "config=", "play=", "diff=", "part=", "mode=", "nbrplayers="]) except getopt.GetoptError: print usage sys.exit(1) playing = None configFile = None debug = False difficulty = 0 part = 0 mode = 0 nbrplayers = 1 for opt, arg in opts: if opt in ["--verbose", "-v"]: Log.quiet = False if opt in ["--debug", "-d"]: debug = True if opt in ["--config", "-c"]: configFile = arg if opt in ["--play", "-p"]: playing = arg if opt in ["--diff", "-D"]: difficulty = arg if opt in ["--part", "-P"]: part = arg #evilynux - Multiplayer and mode selection support if opt in ["--mode", "-m"]: mode = int(arg) if opt in ["--nbrplayers", "-N"]: nbrplayers = int(arg) while True: if configFile != None: if configFile.lower() == "reset": fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini") os.remove(fileName) config = Config.load(Version.appName() + ".ini", setAsDefault = True) else: config = Config.load(configFile, setAsDefault = True) else: config = Config.load(Version.appName() + ".ini", setAsDefault = True) engine = GameEngine(config) engine.cmdPlay = 0 if playing != None: Config.set("game", "selected_library", "songs") Config.set("game", "selected_song", playing) engine.cmdPlay = 1 engine.cmdDiff = int(difficulty) engine.cmdPart = int(part) #evilynux - Multiplayer and mode selection support Config.set("game", "players", nbrplayers) Config.set("player0","mode_1p", mode) Config.set("player1","mode_2p", mode) if debug == True: engine.setDebugModeEnabled(not engine.isDebugModeEnabled()) engine.debugLayer.debugOut(engine) engine.quit() break encoding = Config.get("game", "encoding") if encoding != None: reload(sys) sys.setdefaultencoding(encoding) engine.setStartupLayer(MainMenu(engine)) try: import psyco psyco.profile() except: Log.warn("Unable to enable psyco.") try: while engine.run(): pass except KeyboardInterrupt: pass if engine.restartRequested: Log.notice("Restarting.") engine.audio.close() try: # Determine whether were running from an exe or not if hasattr(sys, "frozen"): if os.name == "nt": os.execl("FretsOnFire.exe", "FretsOnFire.exe", *sys.argv[1:]) elif sys.frozen == "macosx_app": import string import subprocess appname = string.join(string.split(sys.executable, '/')[:-1], '/') appname = appname+"/Frets on Fire" subprocess.Popen(`appname`, shell=True) else: os.execl("./FretsOnFire", "./FretsOnFire", *sys.argv[1:]) else: if os.name == "nt": bin = "c:/python24/python" else: bin = "/usr/bin/python2.4" os.execl(bin, bin, "FretsOnFire.py", *sys.argv[1:]) except: Log.warn("Restart failed.") raise break else: break engine.quit()