def _generateAndSaveKeys(registry=None): registry = registry or Registry_Base_URL k = rsa.generate_private_key(public_exponent=65537, key_size=2048, backend=default_backend()) privatekey_pem = k.private_bytes( serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption() ) pubkey_pem = k.public_key().public_bytes( serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo ) if _isPublicRegistry(registry): settings.setProperty("keys", "private", privatekey_pem.decode("ascii")) settings.setProperty("keys", "public", pubkey_pem.decode("ascii")) else: sources = _getSources() keys = None for s in sources: if _sourceMatches(s, registry): if not "keys" in s: s["keys"] = dict() keys = s["keys"] break if keys is None: keys = dict() sources.append({"type": "registry", "url": registry, "keys": keys}) keys["private"] = privatekey_pem.decode("ascii") keys["public"] = pubkey_pem.decode("ascii") settings.set("sources", sources) return pubkey_pem, privatekey_pem
def onResize(self, event): '''Record new size''' key = 'ui.commsdiagnostics.row.size.' r = 0 while r < self.GetNumberCols(): settings.set(key+str(r), self.GetColSize(r)) r += 1
def OnMove(self, event): """ Event handler for moving window """ x, y = self.GetPosition() settings.set("win.commstest.pos.x", x) settings.set("win.commstest.pos.y", y)
def _getYottaClientUUID(): import uuid current_uuid = settings.get('uuid') if current_uuid is None: current_uuid = u'%s' % uuid.uuid4() settings.set('uuid', current_uuid) return current_uuid
def _dispatch_builtin_command(self, command): self._reset() magic, category, key, value = command.split(':') if magic == 'builtin': if category == 'settings': try: value = eval(value) except e: logging.exception(e) return False if key == 'romanrule': self._charbuf.compile(value) self._charbuf_alter.compile(value) elif key == 'use_title': title.setenabled(value) settings.set(key, value) settings.save() return True elif category == 'task': if key == 'switch': window_id = int(value) if window_id == 0: self._session.blur_process() else: self._draw_nothing(self._output) self._inputmode.reset() self._reset() self._screen.taskswitch(window_id) return False return False
def test_SettingOverwriting(self): # test that values are updated when settings are overwritten s = settings.set('an_index',is_global=IS_GLOBAL,value=12345) t = settings.set('an_index',is_global=IS_GLOBAL,value=67890) self.assert_(s.key() == t.key(), "Set function should not create new objects when existig objects with the same index exist") self.assert_(s.value == 12345, "Initial value should remain in initial object") self.assert_(t.value == 67890, "Updated value should overwrite old value")
def deauthorize(registry=None): registry = registry or Registry_Base_URL if _isPublicRegistry(registry): if settings.get('keys'): settings.set('keys', dict()) else: sources = [s for s in _getSources() if not _sourceMatches(s, registry)] settings.set('sources', sources)
def add_to_ignore(self): gallery = self.gallery_widget.gallery app_constants.IGNORE_PATHS.append(gallery.path) settings.set(app_constants.IGNORE_PATHS, 'Application', 'ignore paths') if self.gallery_widget.parent_widget.gallery_layout.count() == 1: self.gallery_widget.parent_widget.close() else: self.gallery_widget.close()
def accept_edit(self): gallerydb.execute(database.db.DBBase.begin, True) app_constants.APPEND_TAGS_GALLERIES = self.tags_append.isChecked() settings.set(app_constants.APPEND_TAGS_GALLERIES, 'Application', 'append tags to gallery') for g in self._edit_galleries: self.make_gallery(g) self.delayed_close() gallerydb.execute(database.db.DBBase.end, True)
def test_settingTypes(self): # test the creation of settings with different types for k,v in supported_types.iteritems(): s = settings.set(k,is_global=IS_GLOBAL, value=v[0]) self.assert_(s,k+" should create a valid settings object") for k,v in unsupported_types.iteritems(): s = settings.set(k,is_global=IS_GLOBAL, value=v[0]) self.assert_(s == None, "Unsupported types should return None")
def test_SettingHierarchy(self): # test that user settings overwrite global settings where they are present g = settings.set('an_index',is_global=True,value='global value') u = settings.set('an_index',value='user value') self.assert_(g.key() != u.key(),"User settings should not overwrite global settings") s_one = settings.get('an_index') #should be global self.assert_(s_one['value'] == 'global value',"settings.get should return the global value unless user_first is set") s_two = settings.get('an_index',user_first=True) self.assert_(s_two['value'] == 'user value',"User setting should be returned in favour of the global setting when user_first is True")
def delete_file(filename): tries = 10 while os.path.exists(filename) and tries > 0: settings.set('ChannelsUpdated', 0, settingsFile) try: os.remove(filename) break except: tries -= 1
def _static_processing(self): self.logger.info("Static processing thread starting") idx = -1 # resume processing with the last image the user looked at last_img = settings.get('processing/last_img', None) for i, image_name in enumerate(self.images): if image_name == last_img: self.idx = i break while True: with self.condition: # wait until the user hits a key while idx == self.idx and not self.do_stop and not self.do_refresh: self.condition.wait() if self.do_stop: break idx = self.idx self.do_refresh = False # if the index is valid, then process an image if idx < len(self.images) and idx >= 0: image_name = self.images[idx] self.logger.info("Opening %s" % image_name) img = cv2.imread(image_name) if img is None: self.logger.error("Error opening %s: could not read file" % (image_name)) self.camera_widget.set_error() self.idx += self.idx_increment continue try: target_data = self.detector.process_image(img) except: logutil.log_exception(self.logger, 'error processing image') self.camera_widget.set_error(img) else: settings.set('processing/last_img', image_name) settings.save() self.logger.info('Finished processing') # note that you cannot typically interact with the UI # from another thread -- but this function is special self.camera_widget.set_target_data(target_data) self.logger.info("Static processing thread exiting")
def delete_file(filename): dixie.SetSetting("epg.date", "2000-01-01") tries = 10 while os.path.exists(filename) and tries > 0: settings.set("ChannelsUpdated", 0, settingsFile) try: os.remove(filename) break except: tries -= 1
def start_up(self): hello = ["Hello!", "Hi!", "Onii-chan!", "Senpai!", "Hisashiburi!", "Welcome!", "Okaerinasai!", "Welcome back!", "Hajimemashite!"] self.notification_bar.add_text("{} Please don't hesitate to report any bugs you find.".format(hello[random.randint(0, len(hello)-1)])+ " Go to Settings -> About -> Bug Reporting for more info!") level = 5 def normalize_first_time(): settings.set(level, 'Application', 'first time level') settings.save() def done(status=True): gallerydb.DatabaseEmitter.RUN = True if app_constants.FIRST_TIME_LEVEL != level: normalize_first_time() if app_constants.ENABLE_MONITOR and\ app_constants.MONITOR_PATHS and all(app_constants.MONITOR_PATHS): self.init_watchers() if app_constants.LOOK_NEW_GALLERY_STARTUP: if self.manga_list_view.gallery_model.db_emitter.count == app_constants.GALLERY_DATA: self.scan_for_new_galleries() else: self.manga_list_view.gallery_model.db_emitter.DONE.connect(self.scan_for_new_galleries) self.download_manager = pewnet.Downloader() app_constants.DOWNLOAD_MANAGER = self.download_manager self.download_manager.start_manager(4) if app_constants.FIRST_TIME_LEVEL < 4: log_i('Invoking first time level {}'.format(4)) settings.set([], 'Application', 'monitor paths') settings.set([], 'Application', 'ignore paths') app_constants.MONITOR_PATHS = [] app_constants.IGNORE_PATHS = [] settings.save() done() elif app_constants.FIRST_TIME_LEVEL < 5: log_i('Invoking first time level {}'.format(5)) app_widget = misc.ApplicationPopup(self) app_widget.note_info.setText("<font color='red'>IMPORTANT:</font> Application restart is required when done") app_widget.restart_info.hide() self.admin_db = gallerydb.AdminDB() self.admin_db.moveToThread(app_constants.GENERAL_THREAD) self.admin_db.DONE.connect(done) self.admin_db.DONE.connect(lambda: app_constants.NOTIF_BAR.add_text("Application requires a restart")) self.admin_db.DONE.connect(self.admin_db.deleteLater) self.admin_db.DATA_COUNT.connect(app_widget.prog.setMaximum) self.admin_db.PROGRESS.connect(app_widget.prog.setValue) self.admin_db_method_invoker.connect(self.admin_db.rebuild_db) self.admin_db_method_invoker.connect(app_widget.show) app_widget.adjustSize() db_p = os.path.join(os.path.split(database.db_constants.DB_PATH)[0], 'sadpanda.db') self.admin_db_method_invoker.emit(db_p) else: done()
def save_teams(): r = api.method('/me/teams') if r.status_code == 200: teams = r.json() if len(teams) > 0: settings.set(teams=teams) for team in teams: save_image('http:' + team["thumbUrl"], 'team-' + team['name']) n.notify("AndBang Workflow Success", "Your teams were saved!", "Teams: " + ', '.join([team["name"] for team in teams])) else: n.notify("AndBang Workflow Error", "No teams were saved", "Please create one at http://andbang.com") else: n.notify("AndBang Workflow Error", resp["message"], "")
def load_settings(self): settings = ConfigParser.ConfigParser() # Fill defaults settings.add_section("main") settings.set("main", "save-before-build", "True") settings.set("main", "ptp-debug", "False") filename = self.get_settings_filename() if os.path.isfile(filename): with open(filename, "r") as f: settings.readfp(f) return settings
def POST(self): """ Save settings :return: """ inputs = web.input(jobs=[]) cfg = settings.get() cfg["master"] = inputs.serveraddress cfg["jobs"] = inputs.jobs settings.set(cfg) return self.GET()
def select_source(): mc.ShowDialogWait() window = mc.GetActiveWindow() list = window.GetList(SOURCES_LIST_ID) sourceitem = list.GetItem(list.GetFocusedItem()) username = settings.get('megaupload.username') password = settings.get('megaupload.password') cookie = settings.get('megaupload.cookie') print "MU: %s, %s, %s" % (username, password, cookie) mu = megaupload.MegaUpload(username, password, cookie) settings.set('megaupload.cookie', mu.get_cookie()) link, name, wait, cookie = mu.resolve(sourceitem.GetPath()) hide_popup() wd = waitdialog.WaitDialog('Megaupload', 'Waiting for link to activate') wd.wait(wait, waitdialog_callback, (link, name, cookie))
def setAPIKey(registry, api_key): """ Set the api key for accessing a registry. This is only necessary for development/test registries. """ if (registry is None) or (registry == Registry_Base_URL): return sources = _getSources() source = None for s in sources: if _sourceMatches(s, registry): source = s if source is None: source = {"type": "registry", "url": registry} sources.append(source) source["apikey"] = api_key settings.set("sources", sources)
def test_createBasicSetting(self): # test the creation of a basic settings object a_string = "BARfoo" an_index = "BARfoo_global_setting" s = settings.set(an_index,is_global=IS_GLOBAL,value=a_string) self.assert_(s.value == a_string, "Stored value: "+a_string+" retrieved: "+str(s.value)) self.assert_(s.index == an_index, "Provided key: "+an_index+" retrieved: "+str(s.index))
def start_up(self): # TODO: Remove in beta level = 4 def normalize_first_time(): settings.set(level, 'Application', 'first time level') settings.save() def done(status=True): gallerydb.DatabaseEmitter.RUN = True if gui_constants.FIRST_TIME_LEVEL != level: normalize_first_time() if gui_constants.ENABLE_MONITOR and\ gui_constants.MONITOR_PATHS and all(gui_constants.MONITOR_PATHS): self.init_watchers() if gui_constants.LOOK_NEW_GALLERY_STARTUP: if self.manga_list_view.gallery_model.db_emitter.count == gui_constants.GALLERY_DATA: self.scan_for_new_galleries() else: self.manga_list_view.gallery_model.db_emitter.DONE.connect(self.scan_for_new_galleries) self.download_manager = pewnet.Downloader() gui_constants.DOWNLOAD_MANAGER = self.download_manager self.download_manager.start_manager(4) if gui_constants.FIRST_TIME_LEVEL < 3: log_i('Invoking first time level {}'.format(level)) app_widget = misc.ApplicationPopup(self) self.admin_db = gallerydb.AdminDB() self.admin_db.moveToThread(gui_constants.GENERAL_THREAD) self.admin_db.DONE.connect(done) self.admin_db.DONE.connect(self.admin_db.deleteLater) self.admin_db.DATA_COUNT.connect(app_widget.prog.setMaximum) self.admin_db.PROGRESS.connect(app_widget.prog.setValue) self.admin_db_method_invoker.connect(self.admin_db.rebuild_galleries) self.admin_db_method_invoker.connect(app_widget.show) app_widget.adjustSize() self.admin_db_method_invoker.emit() elif gui_constants.FIRST_TIME_LEVEL < 4: log_i('Invoking first time level {}'.format(level)) settings.set([], 'Application', 'monitor paths') settings.set([], 'Application', 'ignore paths') gui_constants.MONITOR_PATHS = [] gui_constants.IGNORE_PATHS = [] settings.save() done() else: done()
def save_members(): output = [] teams = settings.get('teams', []) for team in teams: r = api.method('/members', team['id']) if r.status_code == 200: members = r.json() if len(members) > 0: for member in members: save_image('http:' + member["smallPicUrl"], 'member-' + member['id']) output.append({your_key: member[your_key] for your_key in ['id', 'username', 'smallPicUrl', 'firstName', 'lastName']}) settings.set(members=output) n.notify("AndBang Workflow Success", "Your teams members were saved!", "") else: n.notify("AndBang Workflow Error", "No members were saved", "Have some people join your team!") else: error = r.json() n.notify("AndBang Workflow Error", error["message"], "")
def OnMove(self, event): """Event handler for moving window""" if self.iconized or self.IsMaximized(): return h, w = self.GetSize() settings.set("win.main.size.h", h) settings.set("win.main.size.w", w) x, y = self.GetPosition() settings.set("win.main.pos.x", x) settings.set("win.main.pos.y", y)
def setAPIKey(registry, api_key): ''' Set the api key for accessing a registry. This is only necessary for development/test registries. ''' if (registry is None) or (registry == Registry_Base_URL): return sources = _getSources() source = None for s in sources: if _sourceMatches(s, registry): source = s if source is None: source = { 'type':'registry', 'url':registry, } sources.append(source) source['apikey'] = api_key settings.set('sources', sources)
def OnMove(self, event): '''Event handler for moving window''' if self.iconized or self.IsMaximized(): return h, w = self.GetSize() settings.set('win.main.size.h', h) settings.set('win.main.size.w', w) x, y = self.GetPosition() settings.set('win.main.pos.x', x) settings.set('win.main.pos.y', y)
def do_GET(self): global run_server parse = urlparse.urlparse(self.path) query = urlparse.parse_qs(parse.query) self.send_response(200) self.send_header('Content-type','text-html') self.end_headers() message = 'Token was not saved. Please try again.' if 'access_token' in query: token = query['access_token'][0] settings.set(token=token) message = 'Token has been saved. You may close this window.' run_server = False refresh_script = "<script>h = window.location.href; !!~h.indexOf('#') ? (window.location.href = h.replace('#', '?')) : document.write('" + message + "');</script>" self.wfile.write(refresh_script) return
def _generateAndSaveKeys(registry=None): registry = registry or Registry_Base_URL k = rsa.generate_private_key( public_exponent=65537, key_size=2048, backend=default_backend() ) privatekey_pem = k.private_bytes( serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption() ) pubkey_pem = k.public_key().public_bytes( serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo ) if _isPublicRegistry(registry): settings.setProperty('keys', 'private', privatekey_pem.decode('ascii')) settings.setProperty('keys', 'public', pubkey_pem.decode('ascii')) else: sources = _getSources() keys = None for s in sources: if _sourceMatches(s, registry): if not 'keys' in s: s['keys'] = dict() keys = s['keys'] break if keys is None: keys = dict() sources.append({ 'type':'registry', 'url':registry, 'keys':keys }) keys['private'] = privatekey_pem.decode('ascii') keys['public'] = pubkey_pem.decode('ascii') settings.set('sources', sources) return pubkey_pem, privatekey_pem
def _wasSettingsChanged(self, addon): settingsChanged = False count = 0 params = settings.getAll(settingsFile) for pair in params: param = pair[0] if param in SETTINGS_TO_CHECK: count += 1 if pair[1] != addon.getSetting(param): settingsChanged = True if count != len(SETTINGS_TO_CHECK): settingsChanged = True #update (or create) file if settingsChanged or len(params) == 0: for param in SETTINGS_TO_CHECK: value = addon.getSetting(param).decode('utf-8', 'ignore') settings.set(param, value, settingsFile) dixie.log('Settings changed: ' + str(settingsChanged)) return settingsChanged
def setUp(self): self.tickets = mock.create_autospec(GestioTiquets) self.tickets.consulta_tiquet_dades.return_value = { "solicitant": "usuari.real", "emailSolicitant": "*****@*****.**" } self.identitat = mock.create_autospec(GestioIdentitat) self.identitat.obtenir_uid.return_value = None settings.init() settings.set("regex_reply", "(.*)") # Una que trobi sempre algo settings.set("regex_privat", "X") # Una que no trobi mai res settings.set("usuari_extern", "usuari.extern")
def _updateChannelAndProgramListCaches(self, date, progress_callback, clearExistingProgramList): sqlite3.register_adapter(datetime.datetime, self.adapt_datetime) sqlite3.register_converter('timestamp', self.convert_datetime) if not self._isCacheExpired(date): return self.updateInProgress = True self.updateFailed = False dateStr = date.strftime('%Y-%m-%d') if len(self.channelDict) == 0: channels = self.getAllChannels() for channel in channels: theChannel = self.getChannelFromFile(channel) if theChannel: self.channelDict[channel] = theChannel try: dixie.log('Updating caches...') if progress_callback: progress_callback(0) if self.settingsChanged: self.source.doSettingsChanged() self.settingsChanged = False # only want to update once due to changed settings toDelete = self.getAllChannels() weight = 0 imported = imported_channels = imported_programs = 0 for item in self.source.getDataFromExternal( date, progress_callback): imported += 1 if isinstance(item, Channel): imported_channels += 1 channel = item clean = CleanFilename(channel.id) if clean in toDelete: toDelete.remove(clean) weight += 1 channel.weight = weight self.createChannel(channel) #channels updated try: settings.set('ChannelsUpdated', self.adapt_datetime(datetime.datetime.now()), settingsFile) except: pass self.deleteOldChannels(toDelete) if imported_channels == 0: self.updateFailed = True if imported_programs == 0: self.updateFailed = (not USE_DB_FILE) except SourceUpdateCanceledException: # force source update on next load try: settings.set('ChannelsUpdated', 0, settingsFile) except: pass except Exception: import traceback as tb import sys (etype, value, traceback) = sys.exc_info() tb.print_exception(etype, value, traceback) try: # invalidate cached data try: settings.set('ChannelsUpdated', 0, settingsFile) except: pass except: pass self.updateFailed = True update = dixie.GetSetting('updated.channels') if int(update) < 0: dixie.SetSetting('updated.channels', 0) dixie.SetSetting('current.channels', 0) else: dixie.SetSetting('current.channels', update) self.channelDict = {} self.updateInProgress = False self.initializeChannels() self.updateInProgress = False
def test_set(self): settings.set('local', 'test', '1') self.assertTrue(settings.contains('local')) self.assertEqual(settings.get('local', 'test'), '1')
def test_set_overwrite(self): settings.set('global', 'foo', 'xxx') self.assertEqual(settings.get('global', 'foo'), 'xxx')
def do_init(self, license): opts, files = self.tmpopts, self.tmpfiles del self.tmpopts del self.tmpfiles ## del self.tmplicensedialog import MMurl import windowinterface if features.lightweight and len(files) > 1: windowinterface.showmessage( 'Cannot open multiple files in this product.') files = files[:1] self._license = license ## if not self._license.have('save'): ## windowinterface.showmessage( ## 'This is a demo version.\n'+ ## 'You will not be able to save your changes.', ## title='CMIFed license') self._tracing = 0 self.tops = [] self._mm_callbacks = {} self.last_location = '' self._untitled_counter = 1 self.template_info = None try: import mm, posix, fcntl except ImportError: pass else: pipe_r, pipe_w = posix.pipe() mm.setsyncfd(pipe_w) self._mmfd = pipe_r windowinterface.select_setcallback( pipe_r, self._mmcallback, (posix.read, fcntl.fcntl, fcntl.F_SETFL, posix.O_NDELAY)) self.commandlist = [ EXIT(callback=(self.close_callback, ())), NEW_DOCUMENT(callback=(self.new_callback, ())), OPEN(callback=(self.open_callback, ())), OPENFILE(callback=(self.openfile_callback, ())), OPEN_RECENT(callback=self.open_recent_callback), # Dynamic cascade PREFERENCES(callback=(self.preferences_callback, ())), CHECKVERSION(callback=(self.checkversion_callback, ())), ] import settings if self._license.have('preregistered'): settings.set('registered', 'preregistered') if not self._license.is_evaluation_license() and \ settings.get('registered') != 'preregistered': self.commandlist.append( REGISTER(callback=(self.register_callback, ()))) import Help if hasattr(Help, 'hashelp') and Help.hashelp(): self.commandlist.append(HELP(callback=(self.help_callback, ()))) if __debug__: if settings.get('debug'): self.commandlist = self.commandlist + [ TRACE(callback=(self.trace_callback, ())), DEBUG(callback=(self.debug_callback, ())), CRASH(callback=(self.crash_callback, ())), ] if self.splash is not None: self.splash.unsplash() self.splash = None MainDialog.__init__(self, 'CMIFed', (not not files)) for file in files: self.openURL_callback(MMurl.guessurl(file)) self._update_recent(None) if ENABLE_FNORB_SUPPORT: import CORBA.services self.corba_services = CORBA.services.services(sys.argv) if settings.get('registered') == 'notyet' and \ not self._license.is_evaluation_license(): answer = windowinterface.RegisterDialog() astr = ['yes', 'no', 'notyet'][answer] settings.set('registered', astr) settings.save() if astr == 'yes': self.register_callback()
serv_dir = os.path.join(os.getcwd(), "serv" ) picon_dir = os.path.join(os.getcwd(),'logo') UserDir = os.path.join(os.getcwd(), "user" ) import cookielib sid_file = os.path.join(UserDir, 'vsetv.sid') cj = cookielib.FileCookieJar(sid_file) hr = urllib2.HTTPCookieProcessor(cj) opener = urllib2.build_opener(hr) urllib2.install_opener(opener) try: port = int(settings.get('port')) except: port = 8185 settings.set('port', 8185) if port=='': port = 8185 settings.set('port', 8185) sys.path.append(UserDir) from UserDBcnl import * try: from EPGdb import * if EPG == "": EPG = {} except: EPG = {}
import settings def spider_closing(spider): # Activates on spider closed signal log.msg('closing reactor', level=log.INFO) reactor.stop() log.start(loglevel=log.DEBUG) # logfile=settings.LOG_FILE, settings = Settings() # crawl responsibly settings.set( "USER_AGENT", "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1667.0 Safari/537.36" ) crawler = Crawler(settings) # stop reactor when spider closes crawler.signals.connect(spider_closing, signal=signals.spider_closed) path_prefix = 'spiders.' if len(sys.argv) > 1: spider_name = sys.argv[1] try: custom_spider = importlib.import_module(path_prefix + sys.argv[1]) spider_class = getattr(custom_spider, spider_name) spider = spider_class() except Exception, e: print 'spider:%s 加载失败 ,error:' % spider_name, e
def get_SG(): SG = settings.get("Sel_gr") if SG == '': SG = 'Все каналы' settings.set("Sel_gr", SG) return SG
def syncmodecb(self, arg): settings.set('default_sync_behavior_locked', arg == 'on')
def never_again(self): # Called when the user selects the "don't show again" in the initial dialog import settings settings.set('initial_dialog', 0) settings.save()
def systemtestcb(self, attrname, extvalue): attrvalue = systemtestnames.ext2intvalue(attrname, extvalue) if settings.get(attrname) != attrvalue: settings.set(attrname, attrvalue) self.root.ResetPlayability() return 1 # indicate success
def destroy(self): settings.set('main_window_geometry', self._nametowidget(self.winfo_parent()).geometry()) settings.save() super().destroy()
import discord, datetime, os, time, json, settings from discord.ext import commands from cogs.utils.dataIO import dataIO from pymongo import MongoClient set = settings.set() try: client = MongoClient(host=set.ip, port=set.port, username=set.user, password=set.pwd, authSource=set.auth) db = client['chaemoong']['afk'] lang = client['chaemoong']['mod.language'].find_one except: print("AFK Cog에서 몽고DB를 연결할 수 없습니다!") class Afk(commands.Cog): """asdf!""" def __init__(self, bot): self.bot = bot self.ko = 'data/language/ko.json' self.en = 'data/language/en.json' @commands.command(no_pm=True, name='afk', description='The afk command! | 잠수 명령어입니다!', aliases=['ㅁ라', '잠수', 'wkatn']) async def afk(self, ctx, *, reason=None): """잠수 명령어 입니다!""" utc = datetime.datetime.utcnow()
def __skin_done(self, filename): if filename: import settings, MMurl url = MMurl.pathname2url(filename) settings.set('skin', url) settings.save()