def __init__(self, lang_override=None):
#L_O_G.info('init spellchecker')
self.spellengine = None
self.lang = None
self._need_to_download = None
self.currentDownloads = set()
self.expectedNext = None
# load YAML file describing the dictionaries
filename = program_dir() / 'res' / ('dictionaries-%s.yaml' %
Aspell.VERSION)
try:
with open(filename) as f:
self.dict_info = syck.load(f)
if not isinstance(self.dict_info, dict):
raise ValueError('invalid YAML in %s' % filename)
except Exception:
print_exc()
self.dict_info = {}
# load an engine using swap engine, if no engine is failed use the NullSpellEngine
if not self.SwapEngine(lang_override):
self.spellengine = NullSpellEngine()
profile.prefs.add_observer(
self.on_prefs_change, #@UndefinedVariable
'messaging.spellcheck.enabled',
'messaging.spellcheck.engineoptions.lang',
'messaging.spellcheck.engineoptions.encoding',
'messaging.spellcheck.engineoptions.keyboard',
'messaging.spellcheck.engineoptions.sug-mode') #@UndefinedVariable
def check_manifest_integrity(self, req, resp):
headers = resp.headers
rmtime = headers.get('x-amz-meta-mtime', None)
if rmtime is None:
rmtime = headers.get('last-modified', None)
if rmtime is not None:
rmtime = net.http_date_to_timestamp(rmtime)
if rmtime is not None:
try:
rmtime = int(rmtime)
except (TypeError, ValueError):
rmtime = None
prog_dir = util.program_dir()
self.local_manifest_path = path.path(prog_dir) / path.path(self.remote_manifest_path).splitpath()[-1]
needs_update = True
if self.local_manifest_path.isfile():
lmtime = int(self.local_manifest_path.mtime)
else:
lmtime = 0
if sys.opts.force_update or lmtime != rmtime:
log.info("MTime mismatch or sys.opts.force_update is True. Downloading manifest. (local=%r, remote=%r)", lmtime, rmtime)
downloader.httpopen(self.remote_manifest_path, success = self.got_manifest_response, error = self.manifest_request_error)
else:
log.info("Local MTime matches remote. Not downloading manifest. (local=%r, remote=%r)", lmtime, rmtime)
self.update_check_complete(False, None)
def LoadDigsbyInfo(site_path = 'http://update.digsby.com/', callback = None):
feature_name = 'digsby'
import features.featuresite as FS
import features.pluginresource as PR
import util
feature_site = FS.DigsbyFeatureSite(feature_name, 'update.yaml', site_path, 'digsby-1_0_0', feature_name,
updatesite = site_path, localdir = util.program_dir())
def _after_load_feature(*a):
plugin_site = feature_site.get_plugin_site(config.platform, sys.TAG)
def _after_load_plugin(*a):
plugin_site.content = {'plugins':
{feature_name:
{'dist_types': ['manifest'],
'manifest': {'location': plugin_site.remote.content_location},
'meta' : ''}}}
plugin_info = plugin_site.get_plugin_info(feature_name)
distribution_info = plugin_info.get_best_distribution()
#dist_info = feature_site.get_plugin_site('win', 'release').get_plugin_info('digsby').get_distribution('manifest')
distribution_info.load(callback = callback)
plugin_site.load(success = _after_load_plugin, error = callback.error)
feature_site.load(success = _after_load_feature, error = callback.error)
return feature_site
def __init__(self, lang_override=None):
# L_O_G.info('init spellchecker')
self.spellengine = None
self.lang = None
self._need_to_download = None
self.currentDownloads = set()
self.expectedNext = None
# load YAML file describing the dictionaries
filename = program_dir() / "res" / ("dictionaries-%s.yaml" % Aspell.VERSION)
try:
with open(filename) as f:
self.dict_info = syck.load(f)
if not isinstance(self.dict_info, dict):
raise ValueError("invalid YAML in %s" % filename)
except Exception:
print_exc()
self.dict_info = {}
# load an engine using swap engine, if no engine is failed use the NullSpellEngine
if not self.SwapEngine(lang_override):
self.spellengine = NullSpellEngine()
profile.prefs.add_observer(
self.on_prefs_change, # @UndefinedVariable
"messaging.spellcheck.enabled",
"messaging.spellcheck.engineoptions.lang",
"messaging.spellcheck.engineoptions.encoding",
"messaging.spellcheck.engineoptions.keyboard",
"messaging.spellcheck.engineoptions.sug-mode",
) # @UndefinedVariable
def __init__(self, local_dir = None, temp_dir = None, manifest_path = None, manifest_data = None,
whitelist = None):
self.cancelling = False
self.fast_mode = False
self.quiet_mode = False
self.unchecked_files = None
self.delete_files = []
self.update_files = []
self.good_files = []
if local_dir is None:
local_dir = util.program_dir()
if manifest_path is None:
manifest_path = local_dir / 'manifest'
if manifest_data is None and manifest_path.isfile():
manifest_data = manifest_path.bytes()
self.manifest_path = manifest_path
self.temp_dir = temp_dir or path.path(GetUserTempDir())
self.local_dir = local_dir
self.got_manifest_data(manifest_data)
if whitelist is not None:
self.whitelist = set(whitelist)
known_files = set((self.local_dir/file.path).abspath() for file in self.unchecked_files)
known_files.update((self.local_dir / file).abspath() for file in self.whitelist)
self.delete_files = Cleanup(self.local_dir, known_files)
self.callback = None
def _cache_parts(self, temp):
import util
import digsby_updater.file_integrity as FI
self._location = './manifest'
if temp:
return (FI.GetUserTempDir(), self._location)
else:
return (util.program_dir(), self._location)
def _cache_parts(self, temp):
import util
import digsby_updater.file_integrity as FI
self._location = './manifest'
if temp:
return (FI.GetUserTempDir(), self._location)
else:
return (util.program_dir(), self._location)
def _get_release_notes():
try:
with open(util.program_dir() / 'res' / "release_notes.html", 'rb') as f:
data = f.read()
return data
except Exception, e:
log.error("Release notes not found. %r", e)
return ''
def _get_release_notes():
try:
with open(util.program_dir() / 'res' / "release_notes.html",
'rb') as f:
data = f.read()
return data
except Exception, e:
log.error("Release notes not found. %r", e)
return ''
def prepare_data(self, fast = False):
meths = [getattr(self, meth) for meth in filter(lambda k: not k.startswith('_'),
self.__class__.__dict__.keys())]
meths = filter((lambda meth: hasattr(meth, 'priority')), meths)
if fast:
meths = filter((lambda meth: not getattr(meth, 'slow', False)), meths)
meths.sort(key = attrgetter('priority'))
for meth in meths:
arg_name = getattr(meth, 'arg_name', False)
file_name = getattr(meth, 'file_name', False)
raw_args = getattr(meth, 'raw_args', False)
raw_files = getattr(meth, 'raw_files', False)
if not any((arg_name, file_name, raw_args, raw_files)):
continue
try:
INFO('diagnostic func: %r', meth.__name__)
val = meth()
except Exception:
print_exc()
val = format_exc()
else:
if raw_args:
self.prepared_args.update(val)
if raw_files:
self.prepared_files.update(val)
if arg_name or file_name:
if arg_name: self.prepared_args[arg_name] = val
if file_name: self.prepared_files[file_name] = val
pdir = program_dir()
self.fnames = self.fnames + \
[(pdir/'digsby_updater.log', 'digsby_updater.log'),
(pdir/'digsby.exe.log', 'digsby.exe.log'),
(pdir/'digsby_post_update.log', 'digsby_post_update.log')]
# also include wx log message
with traceguard:
if hasattr(sys, 'STDERR_LOGFILE'):
errfile = sys.STDERR_LOGFILE
self.fnames.append((errfile, os.path.basename(errfile)))
with traceguard:
cstderr = getattr(sys, 'CSTDERR_FILE', None)
if cstderr is not None:
self.fnames.append((cstderr, os.path.basename(cstderr)))
def get_manifest_path(self):
'''
Figure out where the manfiest is supposed to be. Since this may make an HTTP request, control flow
continues asynchronously into got_updateyaml(file_obj).
'''
program_dir = util.program_dir()
local_info_file = program_dir / 'update.yaml'
if local_info_file.isfile():
try:
local_info = open(local_info_file, 'rb')
except Exception:
pass
else:
self.got_updateyaml(fobj = local_info)
return
log.info("Manifest path not found in %r. checking web for update.yaml", local_info_file)
asynchttp.httpopen("http://update.digsby.com/update.yaml?%s" % int(time.time()), success = self.got_updateyaml, error = self.manifest_path_error)
def LoadDigsbyInfo(site_path='http://update.digsby.com/', callback=None):
feature_name = 'digsby'
import features.featuresite as FS
import features.pluginresource as PR
import util
feature_site = FS.DigsbyFeatureSite(feature_name,
'update.yaml',
site_path,
'digsby-1_0_0',
feature_name,
updatesite=site_path,
localdir=util.program_dir())
def _after_load_feature(*a):
plugin_site = feature_site.get_plugin_site(config.platform, sys.TAG)
def _after_load_plugin(*a):
plugin_site.content = {
'plugins': {
feature_name: {
'dist_types': ['manifest'],
'manifest': {
'location': plugin_site.remote.content_location
},
'meta': ''
}
}
}
plugin_info = plugin_site.get_plugin_info(feature_name)
distribution_info = plugin_info.get_best_distribution()
#dist_info = feature_site.get_plugin_site('win', 'release').get_plugin_info('digsby').get_distribution('manifest')
distribution_info.load(callback=callback)
plugin_site.load(success=_after_load_plugin, error=callback.error)
feature_site.load(success=_after_load_feature, error=callback.error)
return feature_site
def get_client_tag():
if getattr(sys, 'DEV', False):
tag = ''
else:
tag = 'release'
tag_fname = 'tag.yaml'
for fpath in ((stdpaths.userlocaldata / tag_fname), (util.program_dir() / tag_fname)):
try:
# If the location or name of this file changes, also update the installer (DigsbyInstaller/DigsbyInstall.nsi)
# since it deletes it.
with open(fpath, 'rb') as f:
yaml = syck.load(f)
tag = yaml['tag']
except Exception, e:
log.debug('Didn\'t get a release tag from %r: %r', fpath, e)
else:
log.info("Got release tag %r from %r", tag, fpath)
break
def for_feature(cls, feat, meta_filepath="./update.yaml", remote_root=None):
if feat.feature_id == "digsby":
import util
assert cls is DigsbyFeatureSite
remote_path = "http://update.digsby.com/"
local_path = util.program_dir()
else:
remote_path = feat.remote_path
local_path = feat.local_path
return cls(
feat.feature_id,
meta_filepath,
remote_path,
feat.platform_version,
feat.feature_id,
localdir=local_path,
updatesite=feat.updatesite,
)
def get_client_tag():
if getattr(sys, 'DEV', False):
tag = ''
else:
tag = 'release'
tag_fname = 'tag.yaml'
for fpath in ((stdpaths.userlocaldata / tag_fname),
(util.program_dir() / tag_fname)):
try:
# If the location or name of this file changes, also update the installer (DigsbyInstaller/DigsbyInstall.nsi)
# since it deletes it.
with open(fpath, 'rb') as f:
yaml = syck.load(f)
tag = yaml['tag']
except Exception, e:
log.debug('Didn\'t get a release tag from %r: %r', fpath, e)
else:
log.info("Got release tag %r from %r", tag, fpath)
break
def for_feature(cls,
feat,
meta_filepath='./update.yaml',
remote_root=None):
if feat.feature_id == 'digsby':
import util
assert cls is DigsbyFeatureSite
remote_path = 'http://update.digsby.com/'
local_path = util.program_dir()
else:
remote_path = feat.remote_path
local_path = feat.local_path
return cls(
feat.feature_id,
meta_filepath,
remote_path,
feat.platform_version,
feat.feature_id,
localdir=local_path,
updatesite=feat.updatesite,
)
def check_manifest_integrity(self, req, resp):
headers = resp.headers
rmtime = headers.get('x-amz-meta-mtime', None)
if rmtime is None:
rmtime = headers.get('last-modified', None)
if rmtime is not None:
rmtime = net.http_date_to_timestamp(rmtime)
if rmtime is not None:
try:
rmtime = int(rmtime)
except (TypeError, ValueError):
rmtime = None
prog_dir = util.program_dir()
self.local_manifest_path = path.path(prog_dir) / path.path(
self.remote_manifest_path).splitpath()[-1]
needs_update = True
if self.local_manifest_path.isfile():
lmtime = int(self.local_manifest_path.mtime)
else:
lmtime = 0
if sys.opts.force_update or lmtime != rmtime:
log.info(
"MTime mismatch or sys.opts.force_update is True. Downloading manifest. (local=%r, remote=%r)",
lmtime, rmtime)
downloader.httpopen(self.remote_manifest_path,
success=self.got_manifest_response,
error=self.manifest_request_error)
else:
log.info(
"Local MTime matches remote. Not downloading manifest. (local=%r, remote=%r)",
lmtime, rmtime)
self.update_check_complete(False, None)
def get_manifest_path(self):
'''
Figure out where the manfiest is supposed to be. Since this may make an HTTP request, control flow
continues asynchronously into got_updateyaml(file_obj).
'''
program_dir = util.program_dir()
local_info_file = program_dir / 'update.yaml'
if local_info_file.isfile():
try:
local_info = open(local_info_file, 'rb')
except Exception:
pass
else:
self.got_updateyaml(fobj=local_info)
return
log.info("Manifest path not found in %r. checking web for update.yaml",
local_info_file)
asynchttp.httpopen("http://update.digsby.com/update.yaml?%s" %
int(time.time()),
success=self.got_updateyaml,
error=self.manifest_path_error)
def __init__(self,
local_dir=None,
temp_dir=None,
manifest_path=None,
manifest_data=None,
whitelist=None):
self.cancelling = False
self.fast_mode = False
self.quiet_mode = False
self.unchecked_files = None
self.delete_files = []
self.update_files = []
self.good_files = []
if local_dir is None:
local_dir = util.program_dir()
if manifest_path is None:
manifest_path = local_dir / 'manifest'
if manifest_data is None and manifest_path.isfile():
manifest_data = manifest_path.bytes()
self.manifest_path = manifest_path
self.temp_dir = temp_dir or path.path(GetUserTempDir())
self.local_dir = local_dir
self.got_manifest_data(manifest_data)
if whitelist is not None:
self.whitelist = set(whitelist)
known_files = set((self.local_dir / file.path).abspath()
for file in self.unchecked_files)
known_files.update(
(self.local_dir / file).abspath() for file in self.whitelist)
self.delete_files = Cleanup(self.local_dir, known_files)
self.callback = None
def defaultprefs():
'''
Returns the default prefs as a Storage object
'''
import prefs
import stdpaths
import config
the_prefs = util.Storage()
resdir = os.path.join(util.program_dir(), 'res')
filenames = [
os.path.join(resdir, 'defaults.yaml'),
os.path.join(resdir, config.platformName, 'defaults.yaml'),
stdpaths.config / 'prefs.yaml',
stdpaths.userdata / 'prefs.yaml',
]
for filename in filenames:
info('loading prefs from %r', filename)
try:
with open(filename, 'rb') as f:
prefdict = syck.load(f)
except Exception, e:
log.info('Error loading prefs from %r: %r', filename, e)
continue
if not isinstance(prefdict, dict):
continue
if not sys.DEV:
prefdict.pop('debug', None)
prefdict = prefs.flatten(prefdict)
the_prefs.update(prefdict)
def defaultprefs():
'''
Returns the default prefs as a Storage object
'''
import prefs
import stdpaths
import config
the_prefs = util.Storage()
resdir = os.path.join(util.program_dir(), 'res')
filenames = [
os.path.join(resdir, 'defaults.yaml'),
os.path.join(resdir, config.platformName, 'defaults.yaml'),
stdpaths.config / 'prefs.yaml',
stdpaths.userdata / 'prefs.yaml',
]
for filename in filenames:
info('loading prefs from %r', filename)
try:
with open(filename, 'rb') as f:
prefdict = syck.load(f)
except Exception, e:
log.info('Error loading prefs from %r: %r', filename, e)
continue
if not isinstance(prefdict, dict):
continue
if not sys.DEV:
prefdict.pop('debug', None)
prefdict = prefs.flatten(prefdict)
the_prefs.update(prefdict)
import syck
import tarfile
import subprocess, _subprocess
from path import path
from util import callsback, threaded, autoassign, program_dir
import stdpaths
from common import setpref
from traceback import print_exc
import logging
log = logging.getLogger('spellchecker')
#L_O_G = log
ASPELLBINDIR = (program_dir() / 'lib' / Aspell.LIBNAME).parent
from subprocess import Popen, PIPE, CalledProcessError
ASPELL_CMD = './lib/aspell/bin/aspell %s -a --ignore-case'
ASPELL_OPT = '--%s="%s"'
ASPELL_DFT = ASPELL_CMD % '--lang=en --encoding=utf-8 --keyboard=standard --sugMode=normal'
def FormAspellCommand(parameters):
options = ' '.join([
ASPELL_OPT % (key, parameters[key].replace('\\', '/'))
for key in parameters
])
cmd = ASPELL_CMD % options
def get_exe_name():
# XXX: this is horrible, can't we have this in a nice clean attribute somewhere?
return util.program_dir().relpathto(path.path(sys._real_exe.decode(locale.getpreferredencoding())))
import tarfile
import subprocess, _subprocess
from path import path
from util import callsback, threaded, autoassign, program_dir
import stdpaths
from common import setpref
from traceback import print_exc
import logging
log = logging.getLogger("spellchecker")
# L_O_G = log
ASPELLBINDIR = (program_dir() / "lib" / Aspell.LIBNAME).parent
from subprocess import Popen, PIPE, CalledProcessError
ASPELL_CMD = "./lib/aspell/bin/aspell %s -a --ignore-case"
ASPELL_OPT = '--%s="%s"'
ASPELL_DFT = ASPELL_CMD % "--lang=en --encoding=utf-8 --keyboard=standard --sugMode=normal"
def FormAspellCommand(parameters):
options = " ".join([ASPELL_OPT % (key, parameters[key].replace("\\", "/")) for key in parameters])
cmd = ASPELL_CMD % options
return cmd
def __init__(self):
import util
super(DigsbyFeature, self).__init__('digsby',
'digsby',
updatesite=digsby_update_site,
dir=util.program_dir())
def __init__(self):
import util
super(DigsbyFeature, self).__init__('digsby', 'digsby', updatesite = digsby_update_site, dir = util.program_dir())
def testapp(pypath = None, appname = 'Digsby', skinname = 'default', prefs = None, username = '******',
on_message = lambda message: None,
plugins = True, logging = True):
'A test application framework for test __main__s.'
if wxMSW: preload_comctrls()
import gettext, os.path
import options
sys.opts, _args = options.parser.parse_args()
import logextensions
digsbysite.COLORIZE_EXCEPTIONS = sys.opts.console_color
# Install gui elements
gettext.install(appname, unicode=True)
from bootstrap import install_N_
install_N_()
# Create the app
app = TestApp()
app.SetAppName(appname)
# initialize stdpaths
from stdpaths import init
init()
if wxMSW:
import gui.native.win.winutil as winutil
winutil.disable_callback_filter()
from gui import skin
from gui.toolbox import setuplogging
if logging:
import logging
setuplogging(level=logging.INFO)
# make wxLogError go to stderr, not popup dialogs
wx.Log.SetActiveTarget(wx.LogStderr())
app.PreShutdown = Delegate()
if pypath is None:
pypath = discover_digsby_root()
sys.path.insert(0, pypath)
skin.set_resource_paths([
util.program_dir() / 'res', # Apparently this has to be first?
stdpaths.userdata,
stdpaths.config,
])
if plugins:
from main import init_plugins
app.plugins = init_plugins()
else:
app.plugins = []
skin.skininit(os.path.join(pypath, 'res'), skinname = skinname)
from util.threads.threadpool import ThreadPool
ThreadPool(5)
from prefs.prefsdata import flatten
import syck
from util.observe import ObservableDict
prefs_path = os.path.join(pypath, 'res', 'defaults.yaml')
prefs = ObservableDict(prefs) if prefs is not None else ObservableDict()
prefs.update({'appearance.skin': skinname,
'appearance.variant': None,
'debug.shell.font': shellfont()})
import common
common.set_active_prefs(prefs, {})
from util.observe import ObservableDict
sys.modules['digsbyprofile'] = Storage()
import digsbyprofile
from common.notifications import default_notifications
p = digsbyprofile.profile = Storage(name = username,
username = username,
prefs = prefs,
on_message = on_message,
notifications = default_notifications)
f = file(prefs_path)
defaults = Storage(flatten(syck.load(f)))
f.close()
user = ObservableDict(defaults)
user.update(prefs)
from prefs.prefsdata import localprefs
import prefs
p.defaultprefs = prefs.defaultprefs()
p.localprefs = localprefs()
import common
common.setfakeprefs(user)
def toggle_prefs(user=user, defaults=defaults):
import prefs
prefs.edit(user, defaults, None)
def toggle_crust(app=app):
if not getattr(app, 'crust', None):
import gui.shell
wins = wx.GetTopLevelWindows()
parent = wins[0] if wins else None
app.crust = gui.shell.PyCrustFrame(None)
if parent is not None:
parent.crust = app.crust
app.crust.Bind(wx.EVT_CLOSE, lambda evt: app.Exit())
app.crust.toggle_shown()
# keyboard focus goes to shell prompt
if app.crust.IsShown():
app.crust.crust.SetFocus()
def on_key(e):
code = e.GetKeyCode()
if code == wx.WXK_F11:
toggle_prefs()
elif code == wx.WXK_F12:
toggle_crust()
elif code == wx.WXK_F5:
from gui import skin
skin.reload()
else:
e.Skip()
app.Bind(wx.EVT_KEY_DOWN, on_key)
app.toggle_crust = toggle_crust
from main import initialize_webkit, SetStatusPrompt
initialize_webkit()
app.SetStatusPrompt = SetStatusPrompt
return app
