def run_one_test(test,verbose=True,update=False):
""" Run a given test name """
child_logger = logger.getChild('run_one_test')
try:
if verbose:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
child_logger.addHandler(ch)
child_logger.info('\nLaunching all tests')
start = time.time()
test_start =time.time()
for potential,element_set in potential_module.supported_atoms.iteritems():
child_logger.info('\nRunning potential=%r',potential)
potential_start = time.time()
for element in element_set:
#figure out if we need to run the test
test_needed = True
if db.results_exist(potential=potential,
element=element,
test=test):
child_logger.info('Test %r,%r,%r exists',test,potential,element)
if new_results_needed(potential,element,test):
child_logger.info('New test needs computing')
test_needed = True
else:
test_needed = False
if update:
test_needed=True
if test_needed:
test_start = time.time()
child_logger.info('\nRunning element=%r',element)
try:
run_test(test=test,
potential=potential,
element=element,
verbose=verbose)
except ImportError as e:
child_logger.error('TRACEBACK: %s',traceback.format_exc())
child_logger.error("test=%r doesn't seem to exist",test)
raise
except Exception as e:
#Some other Error, log it.
child_logger.error('\nERROR on test=%r, potential=%r, element=%r, info:%r',
test,potential,element,e)
child_logger.error('TRACEBACK: %s',traceback.format_exc())
child_logger.info('Element %r Run took %r seconds',element,time.time()-test_start)
else:
child_logger.info('Unessesary test %r,%r,%r',test,potential,element)
child_logger.info('Potential %r run took %r seconds',potential,time.time()-potential_start)
child_logger.info('Test %r run took %r seconds',test,time.time()-test_start)
finally:
child_logger.removeHandler(ch)
def run_tests(verbose=True,update=False):
""" Run all of the tests, where unless update is set,
only compute the results if the test has been modified since
the results. """
child_logger = logger.getChild('run_tests')
try:
if verbose:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
child_logger.addHandler(ch)
child_logger.info('\nLaunching all tests')
start = time.time()
for test in test_list:
child_logger.info('\nRunning tests for test=%r',test)
test_start =time.time()
#Run all of one test
run_one_test(test,verbose=verbose,update=update)
child_logger.info('Test %r run took %r seconds',test,time.time()-test_start)
child_logger.info('Full Run took %r seconds',time.time()-start)
finally:
child_logger.removeHandler(ch)
def KIM_loader(name,element,slab=None,*args,**kwargs):
""" Load a KIM Potential """
child_logger = logger.getChild('KIM_loader')
#Make sure we have slab information
if slab is None:
child_logger.warning('KIM Potential needs slab information')
raise PotentialLoadFailed('KIM',*args,**kwargs)
subspec = slab.get_chemical_symbols()
spec_mass = slab.get_masses()
pair_style = "pair_KIM {name} {spec}".format(name=name,spec=subspec[0])
mass_string = ["* {}".format(spec_mass[0])]
parameters = { "pair_style" : pair_style,
'pair_coeff' : ['* *'],
'mass': mass_string }
default_args = {'tmp_dir':tmp_dir, 'parameters':parameters, 'specorder': subspec}
default_args.update(kwargs)
try:
from kim import KIM
except ImportError:
child_logger.warning('Could not load kim module')
raise PackageDoesNotExist('KIM')
try:
calc = KIM(*args,**default_args)
except:
child_logger.warning('Calculation creation threw exception')
raise PotentialLoadFailed('KIM',*args,**kwargs)
return calc
def EMT_loader(name,element,slab=None,*args,**kwargs):
""" Load an ASE EMT potential """
child_logger = logger.getChild('EMT_loader')
supported_elements = ['Ni','C','Pt','Ag','H',
'Al','O','N','Au','Pd','Cu']
try:
from ase.calculators.emt import EMT
import ase
ase.EMT.disabled = False
except ImportError:
child_logger.warning("ASE doesn't seem to exist")
raise PackageDoesNotExist('ASE:EMT')
try:
calc = EMT(*args,**kwargs)
except:
child_logger.warning("Calculator creation threw exception")
raise PotentialLoadFailed('ASE:EMT',*args,**kwargs)
return calc
def XMLReader(filename=None,test=None,potential=None,element=None,full=False):
"""This method unpacks results to a dictionary,
using json for the serialization"""
child_logger = logger.getChild('XMLReader')
child_logger.debug('XMLReader called...')
#if given a filename, load the file
if filename:
tree = etree.parse(os.path.join(results_dir,filename))
else:
#otherwise, try to find the file
filename = test + '.' + potential + '.' + element + '.xml'
tree = etree.parse(os.path.join(results_dir,filename))
root = tree.getroot()
#get test name
test = root.attrib['id']
#get contrib
config_node = root.find('config')
config = {}
for node in config_node.getchildren():
config[node.tag] = node.text
#get results
results_node = root.find('results')
results = {}
#read each of the results nodes
for node in results_node:
value = simplejson.loads(node.text)
#if a scipy array, cast it as such
if node.attrib == 'ndarray':
value = sp.array(value)
results[node.tag] = value
if full:
# return full results
return test, config, results
return results
def ASAP_loader(name,element,slab=None,*args,**kwargs):
""" Load ASAP potential """
supported_elements = ['Ni','Cu','Pd','Ag','Pt','Au']
child_logger = logger.getChild('ASAP_loader')
try:
import asap3
except ImportError:
child_logger.warning('ASAP package could not be loaded')
raise PackageDoesNotExist('ASAP')
try:
if slab:
size = min(sp.sum(slab.cell,0))
boxes = sp.floor(10/size + 1)
if boxes > 1:
child_logger.warning('Cell Size too small for ASAP')
calc = asap3.EMT(*args,**kwargs)
except:
child_logger.warning('An error occurred in the calculator creation')
raise PotentialLoadFailed('ASAP',*args,**kwargs)
return calc
def run_test(test,potential,element,verbose=True):
""" Run a specific test """
child_logger = logger.getChild('runtest')
try:
if verbose:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
child_logger.addHandler(ch)
child_logger.info('\nAbout to run a test, test=%r,potential=%r,element=%r',
test,potential,element)
start_time = time.time()
child_logger.info('Attempting to load the test')
try:
testModule = __import__('openkimtests.kim_tests.'+test,None,None,fromlist=[test])
except ImportError:
child_logger.error('openkimtests.kim_tests.%r failed to import',test)
raise
testClass = testModule.__getattribute__(test)
child_logger.info('Creating a test instance')
testObject = testClass(potentialname=potential,element=element)
#compute results, and create results file
results = testObject.main()
child_logger.info('Computed results, obtained: %r\n', results)
del testObject
del testClass
del testModule
finally:
#ensure we clear memory up a bit and detach handlers
if verbose:
child_logger.removeHandler(ch)
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
import py2exe
import shutil
from glob import glob
import os
from logger import logger
logging = logger.getChild("Installer")
name = 'TheQube'
__version__ = 0.8
__author__ = 'TheQube developers team'
def get_datafiles():
return [("", ["main.defaults"] + glob('*.exe') + glob("*.dll"))
] + list_all_documentation() + list_session_defaults() + accessible_output_data() + sound_lib_data() + requests_data() + get_soundpacks() + get_locales()
def accessible_output_data():
import accessible_output2
return accessible_output2.find_datafiles()
def sound_lib_data():
import sound_lib
return sound_lib.find_datafiles()
def requests_data():
import requests
path = os.path.join(requests.__path__[0], '*.pem')
# -*- coding: utf-8 -*-
import pycurl
import sys
import threading
import time
import wx
import os
from gui_components.sized import SizedDialog
from logger import logger
logging = logger.getChild('transfer_dialogs')
__all__ = ['TransferDialog', 'DownloadDialog', 'UploadDialog']
class TransferDialog(SizedDialog):
def __init__(self, url=None, filename=None, follow_location=True, completed_callback=None, verbose=False, *args, **kwargs):
self.url = url
self.filename = name
self.curl = pycurl.Curl()
self.start_time = None
self.completed_callback = completed_callback
self.background_thread = None
self.transfer_rate = 0
self.curl.setopt(self.curl.PROGRESSFUNCTION, self.progress_callback)
try:
self.curl.setopt(self.curl.URL, url)
except:
logging.exception("URL error: %s" % self.curl.errstr())
self.curl.setopt(self.curl.NOPROGRESS, 0)
self.curl.setopt(self.curl.HTTP_VERSION, self.curl.CURL_HTTP_VERSION_1_0)
# -*- coding: utf-8 -*-
import wx
from core.gui import SquareDialog
import config
import core.goslate
import operator
from ctypes import windll
from locale import windows_locale
from BeautifulSoup import BeautifulStoneSoup
from logger import logger
logging = logger.getChild('core.gui.translate')
class TranslateDialog(SquareDialog):
t = core.goslate.Goslate()
LCID = windll.kernel32.GetUserDefaultUILanguage()
win_lang = windows_locale[LCID]
def __init__(self, *args, **kwargs):
if 'title' not in kwargs:
kwargs['title'] = _("Translate")
self.title = kwargs['title']
super(TranslateDialog,
self).__init__(style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
*args,
**kwargs)
if not hasattr(self, 'langs'):
self.langs = sorted(self.t.get_languages(
self.get_current_language()).items(),
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.user')
import config
import output
import threading
from tweets import Tweets
from core.sessions.buffers.buffers.dismissable import Dismissable
class Individual(Dismissable, Tweets):
def __init__(self, username="", *args, **kwargs):
self.init_done_event = threading.Event()
self.initial_update = True
self.username = username
logging.debug("Creating user timeline buffer for %s" % self.username)
super(Individual, self).__init__(*args, **kwargs)
self.set_flag('temp', True)
self.item_name = _("tweet from %s") % self.username
self.item_name_plural = _("tweets from %s") % self.username
self.store_args({'username': username})
self.init_done_event.set()
def retrieve_update(self, *args, **kwargs):
timeline = self.timeline_update('get_user_timeline',
since_id=self.get_max_twitter_id(),
screen_name=self.username,
include_rts=True,
include_entities=True)
if self.initial_update:
from logger import logger
logging = logger.getChild('core.sessions.interface.main')
import session
import interface
from core.sessions.session import Session
class Interface (Session):
"""Abstract class which provides a .interface which will have methods meant to interact with the session from a user-interface perspective."""
def __init__ (self, interface=None, *args, **kwargs):
if not interface:
#If no interface is provided, attempt to load a default session interface for current session.
module = self.__module__
module = module.split('.')
module = eval(".".join(module[:-1]))
logging.debug("Current module: %r" % module)
interface = module.interface.interface
logging.debug("Potential interface: %r" % interface)
interface = interface()
self.interface = interface
super(Interface, self).__init__(*args, **kwargs)
from logger import logger
logging = logger.getChild('core.sessions.buffers.interface')
from pydispatch import dispatcher
from utils.thread_utils import call_threaded
from utils.wx_utils import modal_dialog
from core.sessions.buffers.buffer_defaults import buffer_defaults
import config
import output
import gui
import signals
import wx
#Handy decorator:
from core.sessions.buffers.buffer_defaults import buffer_defaults
from core.sessions.sound.interface import SoundInterface
class BuffersInterface (SoundInterface):
@buffer_defaults
def NextItem(self, buffer=None, step=1):
"""Moves to the next item in the current buffer."""
if buffer.index+step >= len(buffer):
self.session.play(self.session.config['sounds']['boundary'])
step = len(buffer)-buffer.index-1
buffer.index = buffer.index+step
buffer.speak_item()
from logger import logger
logging = logger.getChild('core.config')
from configuration import Configuration, ConfigurationResetException
from paths import app_path, data_path
MAINFILE = "Main.conf"
MAINSPEC = "Main.defaults"
main = None
def setup():
global main
try:
main = Configuration(data_path(MAINFILE), app_path(MAINSPEC))
except ConfigurationResetException:
import output
output.speak(
"Unable to load configuration file. Loading default configuration instead.",
0)
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.retweets')
import config
import output
import threading
from tweets import Tweets
from core.sessions.buffers.buffers import Dismissable
class Retweets(Dismissable, Tweets):
def __init__ (self, method, *args, **kwargs):
self.init_done_event = threading.Event()
self.method = method
self.item_name = _('retweet')
self.item_name_plural = _('retweets')
super(Retweets, self).__init__ (*args, **kwargs)
self.store_args({'method':method})
self.temp = False
self.init_done_event.set()
def retrieve_update(self, *args, **kwargs):
if self.method == "retweeted_to_me":
update_function_name='retweeted_to_me'
elif self.method == "retweeted_by_me":
update_function_name = 'retweeted_by_me'
elif self.method == "retweets_of_me":
update_function_name = 'retweeted_of_me'
count = self.count
if count > 100:
# -*- coding: utf-8 -*-
# TheQube profile dialog
# A part of TheQube accessible social networking client
# Copyright © Andre Polykanine A.K.A. Menelion Elensúlë, 2014 — 2015
from logger import logger
logging = logger.getChild("sessions.twitter.gui.profile")
import config
import sessions
import wx
from core.gui import SquareDialog
import calendar
import time
import rfc822
class TwitterProfileDialog(SquareDialog):
def __init__(self, user, *args, **kwargs):
super(TwitterProfileDialog,
self).__init__(title=_("Profile for %s" % user['screen_name']),
*args,
**kwargs)
self.user = user
full_url = unicode(
self.user['entities']['url']['urls'][0]
['expanded_url']) if 'url' in self.user['entities'] else ''
self.screen_name = self.labeled_control(
try:
import pysqlite2.dbapi2 as sqlite
except ImportError:
import sqlite3 as sqlite
from logger import logger
logging = logger.getChild('core.db')
from glob import glob
import global_vars
import paths
import threading
import os
connection = cursor = None
VACUUM_REQUIRED = False
BUFFERS_TABLE = 'Buffers'
def initialize():
global BUFFERS_TABLE
logging.debug("Database: Initializing database subsystem...")
if not TableExists(BUFFERS_TABLE):
CreateBuffersTable()
def CreateBuffersTable():
global BUFFERS_TABLE
logging.debug(
"Database: Creating required table to store buffer metadata...")
command = 'create table "%s" (id integer primary key, name string, index integer, table string, owner string);' % BUFFERS_TABLE
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.home')
import threading
from tweets import Tweets
class Home (Tweets):
"""The Home buffer"""
def __init__ (self, *args, **kwargs):
self.init_done_event = threading.Event()
super(Home, self).__init__(*args, **kwargs)
self.item_name = _("tweet")
self.item_name_plural = _("tweets")
self.item_sound = self.session.config['sounds']['tweetReceived']
self.init_done_event.set()
def retrieve_update(self, *args, **kwargs):
return self.timeline_update(update_function_name='get_home_timeline', since_id=self.get_max_twitter_id(), include_rts=True, include_entities=True)
from logger import logger
logging = logger.getChild("core.i18n")
import application
import config
from i18n_utils import core
import paths
def setup():
logging.info("Initializing the i18n subsystem.")
core.set_active_language(application.name, paths.locale_path(),
config.main['languages']['current'])
def available_languages():
return core.available_languages(paths.locale_path(), application.name)
def printable_lang(lang):
return lang['language']
def printable_available_languages():
langs = available_languages()
return [printable_lang(langs[i]) for i in langs]
def lang_from_printable_language(language):
langs = available_languages()
for i in langs:
# -*- coding: utf-8 -*-
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.main')
from pydispatch import dispatcher
from core.sessions.buffers.buffer_defaults import buffer_defaults
import calendar
import config
import html_filter
import misc
import output
import re
import rfc822
import signals
import time
import wx
from utils.wx_utils import question_dialog
from conditional_template import ConditionalTemplate as Template
from core.sessions.buffers.buffers import Updating
from core.sessions.storage.buffers.storage import Storage
from core.sessions.sound.buffers.audio import Audio
from api_count import APICount
from core.sessions.buffers import field_metadata as meta
class Twitter (Updating, Storage, Audio, APICount):
"""Parent twitter buffer class."""
def __init__ (self, *args, **kwargs):
from logger import logger
logging = logger.getChild('core.sessions.interface.main')
import session
import interface
from core.sessions.session import Session
class Interface(Session):
"""Abstract class which provides a .interface which will have methods meant to interact with the session from a user-interface perspective."""
def __init__(self, interface=None, *args, **kwargs):
if not interface:
#If no interface is provided, attempt to load a default session interface for current session.
module = self.__module__
module = module.split('.')
module = eval(".".join(module[:-1]))
logging.debug("Current module: %r" % module)
interface = module.interface.interface
logging.debug("Potential interface: %r" % interface)
interface = interface()
self.interface = interface
super(Interface, self).__init__(*args, **kwargs)
from logger import logger
logging = logger.getChild('core.gui.schedule')
import time
import wx
from gui_components.sized import SizedPanel
from qube import SquareDialog
__all__ = ['ScheduleDialog', 'TimePanel', 'TimeEntryPanel']
class ScheduleDialog(SquareDialog):
def __init__(self, *args, **kwargs):
super(ScheduleDialog, self).__init__(*args, **kwargs)
self.method = self.labeled_control(_("Select scheduling method"), wx.RadioBox, choices=[_("Interval"), _("Time")], callback=self.on_method_change)
self.current_panel = self.time_panel = TimePanel(parent=self.pane)
self.time_entry_panel = TimeEntryPanel(parent=self.pane)
self.time_entry_panel.Disable()
self.finish_setup()
def on_method_change(self):
current = self.method.GetSelection()
if self.current_panel.Enabled:
self.current_panel.Disable()
if current == 0:
logging.debug("Showing timespan entry panel.")
self.current_panel = self.time_panel
elif current == 1:
logging.debug("Showing time entry panel.")
self.current_panel = self.time_entry_panel
from logger import logger
logging = logger.getChild('sessions.stopwatch.interface')
import output
import gui
from utils.wx_utils import modal_dialog
from core.sessions.buffers.interface import BuffersInterface
from core.sessions.hotkey.interface import HotkeyInterface
from meta_interface import MetaInterface
class StopwatchInterface(BuffersInterface, HotkeyInterface, MetaInterface):
def CountdownTimer(self):
"""Create a timer to count down from the time specified to 0, at which point you will be notified."""
dlg = modal_dialog(gui.CountdownDialog,
parent=self.session.frame,
title=_("Countdown Timer"))
name = dlg.name.GetValue()
time = dlg.get_time()
self.session.create_countdown(name, time)
output.speak(_("Counting."), True)
interface = StopwatchInterface
from logger import logger
logging = logger.getChild('core.end')
import config
import os
import win32api
def end(pid):
PROCESS_TERMINATE = 1
logging.warning("Ending pid: %d" % pid)
handle = win32api.OpenProcess(PROCESS_TERMINATE, False, pid)
win32api.TerminateProcess(handle, -1)
win32api.CloseHandle(handle)
def cend(pid):
import ctypes
PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
def setup():
try:
end(config.main['client']['pid'])
except:
pass
#Save the current pid in the config
config.main['client']['pid'] = os.getpid()
config.main.write()
logging.info("Client PID: %d" % config.main['client']['pid'])
"""
Classes and utility methods to aid in migrating the storage structure.
"""
from logger import logger
logging = logger.getChild('core.sessions.storage_migration')
import sys, os
from datetime import datetime
class MigrationBase(object):
def __init__(self, session):
self.session = session
def forwards(self):
raise NotImplementedError
def backwards(self):
raise NotImplementedError
class Migrator(object):
"""
The migrator takes a session and knows how to migrate it.
The current implementation is durus specific and assumes the session
is a descendent of the storage based session.
"""
def __init__(self, session):
self.session = session
self.connection = session.connection
with session.storage_lock:
# -*- encoding: utf-8 -*-
import requests
import json
from url_shortener import URLShortener
from logger import logger
logging = logger.getChild("core.UrlShorteners.QpsRu")
class QpsruShortener(URLShortener):
api_url = "http://qps.ru/api"
def __init__(self, *args, **kwargs):
self.name = "qps.ru"
return super(QpsruShortener, self).__init__(*args, **kwargs)
def _shorten(self, url):
params = {'url': url}
response = requests.get(self.api_url, params=params)
if response.ok:
return response.text.strip()
else: # Response is not OK
logging.exception("Bad response on shortening URL {}: {}".format(
url, response.status_code))
def created_url(self, url):
return 'qps.ru' in url
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.social_network')
import output
import threading
from users import Users
from core.sessions.buffers.update_type import set_update_type
class SocialNetwork(Users):
def __init__(self, method, session=None, *args, **kwargs):
self.init_done_event = threading.Event()
self.initial_update = True
followers_buffer = None
friends_buffer = None
for i in session.buffers:
if hasattr(i, 'is_followers_buffer') and i.is_followers_buffer:
followers_buffer = i
if hasattr(i, 'is_friends_buffer') and i.is_friends_buffer:
friends_buffer = i
if followers_buffer and friends_buffer:
break
if not (followers_buffer and friends_buffer):
logging.debug(
"No followers or friends buffer found, cannot launch social network buffer."
)
return
self.method = method
self.followers = followers_buffer
self.friends = friends_buffer
from logger import logger
logging = logger.getChild('core.sessions.http_server')
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import cgi
import global_vars
import threading
import wx
from utils.thread_utils import call_threaded
from core.sessions.interface.main import Interface
class HttpServer (Interface):
"""Class which implements an http server for control of this session.
Handles authentication, key-based access, and other metatasks related to providing control."""
def __init__(self, port=0, urlmap={}, *args, **kwargs):
super(HttpServer, self).__init__(*args, **kwargs)
if not hasattr(global_vars, 'http_lock'):
global_vars.http_lock = threading.RLock()
if not port:
port = 7948 #qwit
self.__host_ = '127.0.0.1'
self.__port_ = port
if not urlmap:
urlmap = {'interface': self.interface}
self.urlmap = urlmap
self.handler = Handler
self.handler.session = self
self.server = HTTPServer((self.__host_, self.__port_), self.handler)
logging.debug("%s: Http server setup to listen on http://%s:%d" % (self.name, self.__host_, self.__port_))
from logger import logger
logging = logger.getChild('sessions.gui.main')
#Graphical session
import wx
from core.sessions.session import Session
class Gui(Session):
def __init__(self, name=None, *args, **kwargs):
logging.debug("%s: Creating GUI frame." % name)
self.frame = wx.Frame(None, wx.ID_ANY, name)
self.frame.Center()
super(Gui, self).__init__(name=name, *args, **kwargs)
def shutdown(self, *args, **kwargs):
self.deactivate()
self.frame.Close()
logging.debug("%s: Destroyed GUI frame." % self.name)
super(Gui, self).shutdown(*args, **kwargs)
def deactivate(self):
for child in self.frame.GetChildren():
logging.debug("Destroying window: %r" % child.Title)
wx.CallAfter(child.Destroy)
super(Gui, self).deactivate()
from math import sqrt
import numpy as np
from logger import logger
base_logger = logger.getChild('cancer')
base_logger.info('Inside the neighborlist.py module')
from helper import norm
class NeighborList:
"""Neighbor list object.
cutoffs: list of float
List of cutoff radii - one for each atom.
skin: float
If no atom has moved more than the skin-distance since the
last call to the ``update()`` method, then the neighbor list
can be reused. This will save some expensive rebuilds of
the list, but extra neighbors outside the cutoff will be
returned.
self_interaction: bool
Should an atom return itself as a neighbor?
bothways: bool
Return all neighbors. Default is to return only "half" of
the neighbors.
Example::
nl = NeighborList([2.3, 1.7])
nl.update(atoms)
from logger import logger
logging = logger.getChild('updater')
import os
import wx
from platform_utils import paths
from gui_components.message_boxes import info_message
import application
import shutdown
import updater
from utils.repeating_timer import RepeatingTimer
from utils.thread_utils import call_threaded
from utils.wx_utils import question_dialog
UPDATE_INTERVAL = 3600 #30 minutes
def check_for_update():
if not paths.is_frozen():
return
url = updater.find_update_url(application.update_url, application.version)
if url is None:
return
new_path = os.path.join(paths.app_data_path(application.name), 'updates',
'update.zip')
app_updater = updater.AutoUpdater(url,
new_path,
'bootstrap.exe',
app_path=paths.app_path(),
postexecute=paths.executable_path(),
finish_callback=update_complete)
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.users')
import core.sessions.buffers.field_metadata as meta
from core.sessions.buffers.buffer_defaults import buffer_defaults
from core.sessions.buffers.update_type import set_update_type
from core.sessions.buffers.buffers import Buffer
from main import Twitter
from core.sessions.buffers.buffers import Dismissable
class Users (Dismissable, Twitter):
rapid_access = ['id']
def __init__ (self, username=None, *args, **kwargs):
if not username:
username = kwargs['session'].username
kwargs['count'] = 200
kwargs['maxAPIPerUpdate'] = 15
self.username = username
super(Users, self).__init__(*args, **kwargs)
self.default_template = 'default_followers_friends'
self.store_args({'username':username})
self.buffer_metadata['interval'] = self.session.config['updates']['friendsInterval']
self.set_flag('updatable', False)
self.set_flag('temp', True)
self.set_field('name', _("Name"), None)
self.set_field('screen_name', _("Screen name"), None)
self.set_field('location', _("Location"), None)
self.set_field('bio', _("Description"), 'description')
self.set_field('protected', _("Protected"), None, field_type=meta.FT_BOOL, filter=False)
from logger import logger
logging = logger.getChild('core.sessions.hotkey')
import application
from keyboard_handler.wx_handler import WXKeyboardHandler
from functools import partial, update_wrapper
import config as configuration
import global_vars
import output
from utils.wx_utils import WXDialogCanceled, always_call_after
from core.sessions.interface.main import Interface
from core.sessions.gui.gui import Gui
from core.sessions.configuration.configuration import Configuration
class Hotkey(Configuration, Interface, Gui):
"""A generic session providing global hotkey support"""
def __init__(self, keymap={}, *args, **kwargs):
super(Hotkey, self).__init__(*args, **kwargs)
if 'keymap' not in self.config:
self.config['keymap'] = dict()
self.keymap = self.config['keymap']
#Load any keys passed in.
self.update_dict(self.keymap, keymap)
#Load default app-wide keystrokes.
self.update_dict(self.keymap, configuration.main['keymap'])
self.keyboard_handler = WXKeyboardHandler(application.main_frame)
new = self.keyboard_handler.standardize_keymap(self.keymap)
self.keymap.clear()
from logger import logger
logging = logger.getChild('core.gui.recording')
import os
import output
import sessions
import tempfile
import wx
from utils.thread_utils import call_threaded
from qube import SquareDialog
class RecordingDialog(SquareDialog):
def __init__(self, title=None, *args, **kwargs):
title = title or _("Attach audio")
self.base_title = title
super(RecordingDialog, self).__init__(title=title, *args, **kwargs)
self.file = None
self.recorded = False
self.recording = None
self.playing = None
self.record = self.labeled_control(control=wx.Button, label=_("&Record"))
self.record.Bind(wx.EVT_BUTTON, self.on_record)
self.attach_existing = self.labeled_control(control=wx.Button, label=_("Attach existing audio &file..."))
self.attach_existing.Bind(wx.EVT_BUTTON, self.on_attach_existing)
self.play = self.labeled_control(control=wx.Button, label=_("&Play"))
self.play.Bind(wx.EVT_BUTTON, self.on_play)
self.play.Disable()
self.discard = self.labeled_control(control=wx.Button, label=_("&Discard"))
from helper import norm, unitize
from collections import defaultdict
from math import pow
import scipy as sp
import pprint
from logger import logger
base_logger = logger.getChild('links')
base_logger.info('Inside links.py')
########################################################
### Link Stuff ########################################
########################################################
XSIZE = 20
MAXSTRETCH = 1.2
###########
# custom allclose
###########
from scipy import allclose
def allclose2(a, b, rtol=1e-05, atol=1e-08):
ax, ay = a
bx, by = b
from logger import logger
logging = logger.getChild("core.gui.configuration")
import application
import config
import global_vars
import i18n
import output
import sys
import wx
from core.gui.configuration import ConfigurationDialog
from core.gui.configuration.panels import *
from platform_utils.autostart import windows
class MainConfigDialog (ConfigurationDialog):
def __init__(self, *args, **kwargs):
super(MainConfigDialog, self).__init__(*args, **kwargs)
self.languages = LanguagePanel(self.nb)
self.nb.AddPage(self.languages, _("Language"))
self.speech = SpeechPanel(self.nb)
self.nb.AddPage(self.speech, _("Speech"))
self.navigation = NavigationPanel(self.nb)
self.nb.AddPage(self.navigation, _("Navigation"))
self.braille = BraillePanel(self.nb, -1)
self.nb.AddPage(self.braille, _("Braille"))
self.misc = MiscPanel(self.nb)
self.nb.AddPage(self.misc, _("Miscellaneous"))
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
import py2exe
import shutil
from glob import glob
import os
from logger import logger
logging = logger.getChild("Installer")
name = 'TheQube'
__version__ = 0.9
__author__ = 'Andre Polykanine also known as Menelion Elensúlë'
def get_datafiles():
return [("", ["main.defaults"] + glob('*.exe') + glob("*.dll"))
] + list_all_documentation() + list_session_defaults(
) + accessible_output_data() + sound_lib_data() + certifi_data(
) + get_soundpacks() + get_locales()
def accessible_output_data():
import accessible_output2
return accessible_output2.find_datafiles()
def sound_lib_data():
import sound_lib
return sound_lib.find_datafiles()
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.top_trends')
import output
import threading
from core.sessions.buffers.buffer_defaults import buffer_defaults
from trends import Trends
class TopTrends (Trends):
def __init__ (self, *args, **kwargs):
self.init_done_event = threading.Event()
self.initial_update = True
super(TopTrends, self).__init__ (*args, **kwargs)
self.init_done_event.set()
def retrieve_update(self, *args, **kwargs):
return self.session.api_call('get_place_trends', _("Retrieving trends"), report_success=False, report_failure=False, id=1)[0]['trends']
from logger import logger
logging = logger.getChild('core.sessions.speech_recognition')
import config
import output
import wx
from core.sessions.interface.main import Interface
from core.sessions.configuration.configuration import Configuration
class SpeechRecognition (Configuration, Interface):
def __init__(self, speechmap={}, *args, **kwargs):
super(SpeechRecognition, self).__init__(*args, **kwargs)
for i in speechmap.keys():
speechmap[speechmap[i]] = i
del(speechmap[i])
if not self.config.has_key('speechmap'):
self.config['speechmap'] = {}
self.speechmap = self.config['speechmap']
self.update_dict(self.speechmap, speechmap)
self.speech_module_installed = False
logging.debug("%s: Speech recognition setup. Speechmap has %d items." % (self.name, len(self.speechmap.keys())))
def activate(self):
if config.main['recognition']['enabled']:
self.enable_speech_recognition()
super(SpeechRecognition, self).activate()
def deactivate (self):
if self.speech_module_installed and config.main['recognition']['enabled']:
from logger import logger
logging = logger.getChild('sessions.twitter.interface')
from importer import Importer
from durus_importer import SessionImporter
from core.sessions.buffers.buffer_defaults import buffer_defaults
from utils.delay import delay_action
from utils.thread_utils import call_threaded
from utils.wx_utils import modal_dialog, question_dialog
import config
import calendar
import core.gui
import global_vars
import misc
import os
import output
import paths
import rfc822
import buffers
import gui
import sessions
import templates
import time
import wx
from core.sessions.buffers.interface import BuffersInterface
from core.sessions.hotkey.interface import HotkeyInterface
from meta_interface import MetaInterface
from geopy.geocoders import GoogleV3
# -*- coding: utf-8 -*-
from logger import logger
logging = logger.getChild('sessions.twitter.interface')
from core.sessions.buffers.buffer_defaults import buffer_defaults
from utils.delay import delay_action
from utils.thread_utils import call_threaded
from utils.wx_utils import modal_dialog, question_dialog
from geopy.geocoders import GoogleV3
import config
import calendar
import core.gui
import global_vars
import misc
import os
import output
import paths
import rfc822
import buffers
import gui
import sessions
import templates
import time
import wx
import traceback
from core.sessions.buffers.interface import BuffersInterface
from core.sessions.hotkey.interface import HotkeyInterface
from meta_interface import MetaInterface
from logger import logger
logging = logger.getChild('sessions.buffers.buffers.storage')
from utils.wx_utils import always_call_after
from core.sessions.buffers.buffer_defaults import buffer_defaults
from core.sessions.buffers.buffers.buffer import Buffer
class Storage(Buffer):
"""Buffer class which implements storage on top of the persistent storage session"""
def __init__(self,
session,
name=None,
data=[],
location=None,
*args,
**kwargs):
if not location:
location = name
with session.storage_lock:
self.location = self.SanitizeLocationString(location)
if self.location not in session.storage.keys():
session.storage[self.location] = []
if self.location not in session.buffer_metadata.keys():
session.buffer_metadata[self.location] = {}
self.storage = session.storage[self.location]
self.buffer_metadata = session.buffer_metadata[self.location]
super(Storage, self).__init__(session=session,
name=name,
import scipy as sp
from logger import logger
import pprint
base_logger = logger.getChild('cells')
base_logger.info('Inside cells.py')
########################################################
### Cell Stuff ########################################
########################################################
class CellType(object):
""" A holder for some cell type information
Initialization / Attributes:
* name : string name of cell type
* type_ind : an int for the cell type
* k : spring constant (float)
* L : natural length of bonds (float)
* color='b' : set the color the plots
"""
logger = base_logger.getChild('CellType')
def __init__(self,
name,
type_ind,
k,
L,
color='b',
from logger import logger
logging = logger.getChild('core.sessions.session')
import config
import output
from pydispatch import dispatcher
import signals
from core.named_object import NamedObject
class Session(NamedObject):
def __init__(self, type=None, *args, **kwargs):
self.type = type
self.kind = self.type.lower()
super(Session, self).__init__(*args, **kwargs)
dispatcher.connect(self.initialize,
signals.session_created,
sender=self)
self.active = 0
logging.debug("Created new session: %s" % self.name)
def initialize(self, *args, **kwargs):
try:
self.finish_initialization()
except:
logging.exception("%s: Error finishing initialization." %
self.name)
logging.debug("%s initialized." % self.name)
from logger import logger
logging = logger.getChild('sessions.stopwatch.timers')
import misc
import output
import time
from core.sessions.buffers.buffer_defaults import buffer_defaults
from main import Time
class Timers(Time):
def __init__(self, *args, **kwargs):
super(Timers, self).__init__(*args, **kwargs)
self.default_template = 'timer'
self.set_field('elapsed', _("Elapsed time"), self.get_elapsed)
@buffer_defaults
def get_elapsed (self, item=None):
return misc.SecondsToString(item.elapsed_time(), 3)
@buffer_defaults
def interact(self, index=None):
if not self[index].running and self[index].start_time:
self[index].reset()
self[index].start()
output.speak(_("Stopwatch reset and counting."), True)
elif not self[index].running:
self[index].start()
output.speak(_("Stopwatch counting."), True)
from logger import logger
logging = logger.getChild('core.buffers.updating')
from pydispatch import dispatcher
import config
import output
import sessions
import signals
import threading
from utils.repeating_timer import RepeatingTimer
from utils.thread_utils import call_threaded
from core.sessions.buffers.buffers.buffer import Buffer
from core.sessions.buffers.update_type import set_update_type
class Updating (Buffer):
def __init__ (self, session, interval=None, *args, **kwargs):
self._update_types = dict(initial=1, auto=2, forced=3, default=2)
super(Updating, self).__init__(session, *args, **kwargs)
self.update_lock = threading.Lock()
self.set_flag('updatable', True)
if not interval and interval != 0:
try:
interval = self.buffer_metadata['interval']
except:
interval = session.config.get('updates', {}).get('checkInterval', 0)
self.buffer_metadata['interval'] = interval
self.interval = self.buffer_metadata['interval']
if not hasattr(self, 'item_name'):
from logger import logger
logging = logger.getChild('sessions.twitter.main')
from pydispatch import dispatcher
from utils.thread_utils import call_threaded
from utils.wx_utils import always_call_after
import application
import config
import crypt
import global_vars
import interface
import core.gui
import misc
import oauth2
import output
import buffers
import gui
import sessions
import signals
import stream
import time
import wx
from core.sessions.buffers import Buffers
from session import Login
from core.sessions.hotkey.hotkey import Hotkey
from session import HttpServer
from session import SpeechRecognition
from session import WebService
from twython import Twython, TwythonError
from logger import logger
logging = logger.getChild('sessions.stopwatch.timers')
import misc
import output
import time
from core.sessions.buffers.buffer_defaults import buffer_defaults
from main import Time
class Timers(Time):
def __init__(self, *args, **kwargs):
super(Timers, self).__init__(*args, **kwargs)
self.default_template = 'timer'
self.set_field('elapsed', _("Elapsed time"), self.get_elapsed)
@buffer_defaults
def get_elapsed(self, item=None):
return misc.SecondsToString(item.elapsed_time(), 3)
@buffer_defaults
def interact(self, index=None):
if not self[index].running and self[index].start_time:
self[index].reset()
self[index].start()
output.speak(_("Stopwatch reset and counting."), True)
elif not self[index].running:
self[index].start()
output.speak(_("Stopwatch counting."), True)
try:
import pysqlite2.dbapi2 as sqlite
except ImportError:
import sqlite3 as sqlite
from logger import logger
logging = logger.getChild('core.db')
from glob import glob
import global_vars
import paths
import threading
import os
connection = cursor = None
VACUUM_REQUIRED = False
BUFFERS_TABLE = 'Buffers'
def initialize ():
global BUFFERS_TABLE
logging.debug("Database: Initializing database subsystem...")
if not TableExists (BUFFERS_TABLE):
CreateBuffersTable()
def CreateBuffersTable ():
global BUFFERS_TABLE
logging.debug("Database: Creating required table to store buffer metadata...")
command = 'create table "%s" (id integer primary key, name string, index integer, table string, owner string);' % BUFFERS_TABLE
from logger import logger
logging = logger.getChild('core.gui.schedule')
import time
import wx
from gui_components.sized import SizedPanel
from qube import SquareDialog
__all__ = ['ScheduleDialog', 'TimePanel', 'TimeEntryPanel']
class ScheduleDialog(SquareDialog):
def __init__(self, *args, **kwargs):
super(ScheduleDialog, self).__init__(*args, **kwargs)
self.method = self.labeled_control(_("Select scheduling method"),
wx.RadioBox,
choices=[_("Interval"),
_("Time")],
callback=self.on_method_change)
self.current_panel = self.time_panel = TimePanel(parent=self.pane)
self.time_entry_panel = TimeEntryPanel(parent=self.pane)
self.time_entry_panel.Disable()
self.finish_setup()
def on_method_change(self):
current = self.method.GetSelection()
if self.current_panel.Enabled:
self.current_panel.Disable()
if current == 0:
logging.debug("Showing timespan entry panel.")
from logger import logger
logging = logger.getChild('core.gui.qube')
import output
import sessions
import wx
from gui_components.sized import SizedDialog
class SquareDialog (SizedDialog):
def __init__(self, session=None, *args, **kwargs):
super(SquareDialog, self).__init__(*args, **kwargs)
if session is None:
session = sessions.current_session
if getattr(session, 'modifiers_locked', None):
session.unlock_modifiers()
output.speak(_("Modifiers unlocked."))
#We're interested if this dialog closes.
self.Bind(wx.EVT_CLOSE, self.on_close)
def on_close(self, evt):
evt.Skip()
logging.info("Destroying dialog")
self.Destroy()
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.list')
from core.sessions.buffers.buffer_defaults import buffer_defaults
import config
import output
import sessions
import threading
import wx
from tweets import Tweets
from core.sessions.buffers.buffers import Dismissable
class ListTimeline (Dismissable, Tweets):
def __init__ (self, owner=None, list=None, *args, **kwargs):
self.init_done_event = threading.Event()
if not owner:
owner = kwargs['session'].username
self.owner = owner
self.list = list
super(ListTimeline, self).__init__ (*args, **kwargs)
self.store_args({'list':self.list, 'owner':self.owner})
self.item_name = _("tweet in %s" % self.display_name)
self.item_name_plural = _("tweets in %s" % self.display_name)
if 'spoken' not in self.buffer_metadata.keys():
self.buffer_metadata['spoken'] = self.session.config['templates']['default_template']
if 'clipboard' not in self.buffer_metadata.keys():
self.buffer_metadata['clipboard'] = self.buffer_metadata['spoken']
logging.debug("List timeline %s created with slug %s and owner %s" % (self.name, self.list['slug'], self.owner))
import application
import global_vars
import sys
import wx
import url_shortener
from logger import logger
logging = logger.getChild('config.panels.misc')
from core.gui.configuration import ConfigurationPanel
class MiscPanel (ConfigurationPanel):
def __init__ (self, *args, **kwargs):
super(MiscPanel, self).__init__(*args, **kwargs)
AutoStart_allowed = hasattr(sys, 'frozen') and not global_vars.portable
self.AutoStart = wx.CheckBox(self, -1, _("Automatically start %s after Windows log on?") % application.name)
self.AskForExit = wx.CheckBox(self, -1, _("Show confirmation dialog before exiting %s?") % application.name)
wx.StaticText(parent=self, label=_("Preferred URL Shortener:"))
self.shorteners = wx.ComboBox(parent=self, choices=url_shortener.list_services(), style = wx.CB_READONLY)
self.shorteners.SetSizerProps(expand=True)
wx.StaticText(parent=self, label=_("Preferred audio service:"))
# M. E.: I don't see why we should not hard-code this list for now
allAudioServices = ['sndup.net', 'twup.me']
self.audioServices = wx.ComboBox(parent=self, choices=allAudioServices, style = wx.CB_READONLY)
self.audioServices.Bind(wx.EVT_COMBOBOX, self.onChange)
self.audioServices.SetSizerProps(expand=True)
self.sndupKeySizer = wx.BoxSizer(wx.HORIZONTAL)
self.sndupKeyLabel = wx.StaticText(parent=self, label=_("Your Sndup.net API Key:"))
self.sndupKey = wx.TextCtrl(parent=self)
self.sndupKey.SetSizerProps(expand=True)
self.sndupKeySizer.Add(self.sndupKeyLabel)
self.sndupKeySizer.Add(self.sndupKey)
self.sendMessagesWithEnterKey = wx.CheckBox(self, label=_("Send Messages With Enter Key?"))
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.sent')
from core.sessions.buffers.buffer_defaults import buffer_defaults
import calendar
import rfc822
from conditional_template import ConditionalTemplate as Template
import output
import threading
from tweets import Tweets
from main import Twitter
from core.sessions.buffers.update_type import set_update_type
from core.sessions.buffers import field_metadata as meta
class Sent(Tweets):
def sort_key(self, item):
return self.standardize_timestamp(item["created_at"])
def __init__(self, *args, **kwargs):
self.init_done_event = threading.Event()
self.item_name = _("sent item")
self.item_name_plural = _("sent items")
super(Sent, self).__init__(*args, **kwargs)
if 'spoken' not in self.buffer_metadata or self.buffer_metadata[
'spoken'] == self.session.config['templates'][
'default_template']:
self.buffer_metadata[
'spoken'] = '$if(geo){*geo* } about $when, $if(dm){DM to $rcpt_name: }$message'
if 'clipboard' not in self.buffer_metadata.keys():
# -*- encoding: utf-8 -*-
import requests
import json
from url_shortener import URLShortener
from logger import logger
logging = logger.getChild("core.UrlShorteners.UxNu")
class UxnuShortener (URLShortener):
api_url = "http://ux.nu/api/short"
def __init__ (self, *args, **kwargs):
self.name = "ux.nu"
return super(UxnuShortener, self).__init__(*args, **kwargs)
def _shorten (self, url):
params = {'url': url}
response = requests.get(self.api_url, params=params)
if response.ok:
try:
data = response.json()
except ValueError as e:
logging.exception("Value error upon shortening the URL: {}: {}".format(url, e))
return data['data']['url']
else: # Response is not OK
logging.exception("Bad response on shortening URL {}: {}".format(url, response.status_code))
def created_url (self, url):
return 'ux.nu' in url
from helper import norm, unitize
from collections import defaultdict
from math import pow
import scipy as sp
import pprint
from logger import logger
base_logger = logger.getChild('links')
base_logger.info('Inside links.py')
########################################################
### Link Stuff ########################################
########################################################
XSIZE=20
MAXSTRETCH = 1.2
###########
# custom allclose
###########
from scipy import allclose
def allclose2(a,b,rtol=1e-05,atol=1e-08):
from logger import logger
logging = logger.getChild('sessions.twitter.buffers.favorites')
from core.sessions.buffers.buffer_defaults import buffer_defaults
import config
import output
import threading
from tweets import Tweets
from main import Twitter
from core.sessions.buffers.buffers import Dismissable
class Favorites (Dismissable, Tweets):
"""
Buffer to show all favorited tweets.
Deleting a tweet from this buffer will actually unfavorite it.
"""
def __init__(self, username=None, *args, **kwargs):
self.init_done_event = threading.Event()
self.initial_update = True
if not username:
username = kwargs['session'].username
kwargs['maxAPIPerUpdate'] = 100
self.username = username
super(Favorites, self).__init__(*args, **kwargs)
self.item_name = _("favorite")
self.item_name_plural = _("favorites")
self.store_args(dict(username=username))
self.init_done_event.set()
def retrieve_update(self, *args, **kwargs):
from logger import logger
logging = logger.getChild('core.buffers.dismissable')
from core.sessions.buffers.buffers.buffer import Buffer
class Dismissable (Buffer):
"""
Abstract buffer that makes a sound when opened and closed and can be dismissed.
"""
def __init__ (self, session, *args, **kwargs):
super(Dismissable, self).__init__(session, *args, **kwargs)
self.set_flag('deletable', True)
session.play(session.config['sounds']['newBuffer'])
def shutdown (self, end=False, *args, **kwargs):
super(Dismissable, self).shutdown(end, *args, **kwargs)
if not end:
self.session.play(self.session.config['sounds']['dismissBuffer'])
from logger import logger
logging = logger.getChild('core.buffers.dismissable')
from core.sessions.buffers.buffers.buffer import Buffer
class Dismissable(Buffer):
"""
Abstract buffer that makes a sound when opened and closed and can be dismissed.
"""
def __init__(self, session, *args, **kwargs):
super(Dismissable, self).__init__(session, *args, **kwargs)
self.set_flag('deletable', True)
session.play(session.config['sounds']['newBuffer'])
def shutdown(self, end=False, *args, **kwargs):
super(Dismissable, self).shutdown(end, *args, **kwargs)
if not end:
self.session.play(self.session.config['sounds']['dismissBuffer'])
