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