def test_lazyimport(self):
"""
Test that the viz module is lazily imported.
"""
self.assertEqual(type(gvas.viz.sns), type(lazyModule('seaborn')))
self.assertEqual(type(gvas.viz.plt), type(lazyModule('matplotlib.pyplot')))
self.assertEqual(type(gvas.viz.np), type(lazyModule('numpy')))
self.assertEqual(type(gvas.viz.pd), type(lazyModule('pandas')))
def __init__(self, app):
self.variables = dict(
app=app,
chandler=chandler,
peak=peak,
wx=imports.lazyModule('wx'),
)
def dispatchTasks(wkbk, start_row):
min_row = 0
if start_row is None:
min_row = 2
else:
min_row = int(start_row) - 2
shtTasks = wkbk.worksheet("Tasks")
namesTasks = shtTasks.col_values(1)
stateTasks = shtTasks.col_values(4)
# Having the name of each handler, dispatch to them
print 'Start work at row #{} in the "Tasks" sheet.'.format(min_row + 2)
complete = 0
for row, task in enumerate(namesTasks):
# print 'Row is #{}/{} '.format(row,min_row)
# print 'Task #{} has {} to do.'.format(row+1,stateTasks[row])
if row > min_row:
if task not in ("Model Class", "", None)\
and int(stateTasks[row]) > 0:
print '\n\nTask#{} uses the module "{}".'.format(row + 1, task)
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
getattr(
lazyModule('models.' + task), task)().process(wkbk, row)
complete += 1
print 'Found {} tasks to process.'.format(complete)
return
def __init__(self, app):
self.variables = dict(
app=app,
chandler=chandler,
peak=peak,
wx=imports.lazyModule('wx'),
)
def __init__(self, conf=None):
if conf is None:
conf = lazyModule('hammock.conf')
server = 'http://{0}:{1}/'.format(
conf.settings['couch']['host'],
conf.settings['couch']['port'])
super(Server,self).__init__(server)
self.resource.credentials = ( conf.settings['couch']['username'],
base64.b64decode(conf.settings['couch']['password']) )
def toBases(bases, name=''):
if isinstance(bases, (str, ModuleType)):
bases = bases,
for b in bases:
if isinstance(b, str):
b = lazyModule(name, b)
yield b
"""API functions and classes for the peak.naming package"""
from interfaces import *
from syntax import *
from names import *
from contexts import *
import spi
from peak.util.imports import lazyModule
URL = lazyModule(__name__, '../URL')
del lazyModule
def InitialContext(parent, componentName=None, **options):
"""Get an initial naming context, based on 'parent' and keyword options
'parent' is the component which will be used as the naming context's
parent component, to obtain any required configuration data. The
'componentName' argument and 'options' keyword arguments are used
to set up the context's name and attributes, just as with a normal
PEAK component constructor.
This function implements the 'binding.IComponentFactory' interface, and
thus can be used as a factory for a 'binding.Make()' attribute. That
is, you can do this::
myInitCtx = binding.Make(naming.InitialContext)
in a class to create a 'myInitCtx' attribute. This can be useful if
you will be using naming functions a lot and would like to hang onto
an initial context.
""" goulash.bin._goulash
"""
import os
from argparse import ArgumentParser
from peak.util.imports import lazyModule
from goulash import version
fileserver = lazyModule('goulash.fileserver')
inspect = lazyModule('goulash._inspect')
projects = lazyModule('goulash.projects')
boiler = lazyModule('goulash.bin.boiler')
from goulash.docs import docs_handler
from jinja2 import Template
def get_parser():
""" build the default parser """
parser = ArgumentParser()
# parser.set_conflict_handler("resolve")
parser.add_argument(
"-v", '--version', default=False, dest='version',
action='store_true',
help=("show version information"))
subparsers = parser.add_subparsers(help='commands')
help_parser = subparsers.add_parser('help', help='show help info')
help_parser.set_defaults(subcommand='help')
bparser = subparsers.add_parser('boiler', help='boilerplate generation')
bparser.add_argument(
def testIt(self, task):
getattr(lazyModule('models.' + task), task)().test("AAA")
return
from threads import *
from net import *
from callbacks import callsback, DefaultCallback, CallLater
from fileutil import *
def soupify(*a, **k): #this method exists so that BeautifulSoup isn't imported until needed.
import BeautifulSoup
return BeautifulSoup.BeautifulSoup(*a, **k)
import urllib2_file #side effects
import proxy_settings #side effects
#from ie import IEEvents, IEBrowser, JavaScript, GetIE
observe = lazyModule('util.observe')
### SOME MONKEYPATCHING
import rfc822
__old_init = rfc822.Message.__init__
__old_str = rfc822.Message.__str__
def __init__(self, fp, *a, **k):
if isinstance(fp, basestring):
from cStringIO import StringIO
return __old_init(self, StringIO(fp), *a, **k)
else:
return __old_init(self, fp, *a, **k)
# Distributed under the terms of the GNU Lesser General Public License
# http://www.gnu.org/copyleft/lesser.html
__all__ = ['write_dot', 'read_dot', 'graphviz_layout', 'pydot_layout',
'to_pydot', 'from_pydot']
import sys
from networkx.utils import _get_fh
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
pydot=lazyModule('pydot')
def write_dot(G,path):
"""Write NetworkX graph G to Graphviz dot format on path.
Path can be a string or a file handle.
"""
fh=_get_fh(path,'w')
P=to_pydot(G)
fh.write(P.to_string())
fh.flush() # might be a user filehandle so leave open (but flush)
return
def read_dot(path):
"""Return a NetworkX Graph or DiGraph from a dot file on path.
def doImport(parser, data):
attrs = SOX.validatedAttributes(parser, data, ('module', ), ('as', ))
module = str(attrs['module'])
as_ = attrs.get('as', module.split('.')[-1])
getGlobals(data['previous'])[as_] = lazyModule(module)
import cPickle
import codecs
import locale
import string
import sys
import time
from networkx.utils import is_string_like, _get_fh
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
yaml=lazyModule('yaml')
def write_yaml(G, path, default_flow_style=False, **kwds):
"""Write graph G in YAML text format to path.
See http://www.yaml.org
"""
fh=_get_fh(path,mode='w')
yaml.dump(G,fh,default_flow_style=default_flow_style,**kwds)
def read_yaml(path):
"""Read graph from YAML format from path.
See http://www.yaml.org
import wx
import sys
import actionIDs
from peak.util.imports import lazyModule
common = lazyModule('common')
from eventStack import AppEventHandlerMixin
config = lazyModule('config')
from weakref import WeakValueDictionary
def stub():
pass
def tracecall(fn):
"""
This decorator allows us to register that an event handler has fired
during automated tests.
"""
def trace(*args):
if getattr(wx.GetApp(), "testing", False):
wx.GetApp().event_fired = fn
print "function %r fired" % fn
return stub
else:
return fn(*args)
return trace
def declareModule(name, relativePath=None, bases=(), patches=()):
"""Package Inheritance Shortcut and Third-party Patches
This function lets you "pre-declare" that a module should have
some set of bases or "patch modules" applied to it. This lets
you work around the single-inheritance limitation of package
inheritance, and it also lets you apply "patch modules" to
third-party code that doesn't call 'setupModule()'.
To use this, you must call it *before* the module has been
imported, even lazily. You can call it again as many times
as you like, as long as the base and patch lists remain the
same for a given module. Also note that the module must *exist*;
that is, there must be some Python-findable source or bytecode
for the specified module. It can be "inherited" via package
inheritance from its containing package's base package; you just
can't make up a phony module name and have it work. (This limitation
might get lifted later, if it turns out to be useful.)
'bases' are placed in the target module's '__bases__', *after*
any bases declared in the package. 'patches' are applied as
though they were the first modules to call 'patchModule()'.
So the overall "MRO" for the resulting module looks like this:
1. patches by modules calling 'patchModule()'
2. modules specified by 'declareModule(patches=)'
3. the module itself
4. any '__bases__' declared by the module
5. base modules supplied by 'declareModule(bases=)'
Note that both 'bases' and 'patches' may be modules,
relative paths to modules (relative to the declared module,
*not* the 'name' parameter), or tuples of modules or paths.
Using 'declareModule()' makes it easier to do multiple inheritance
with packages. For example, suppose you have packages 'square'
and 'circle', and want to make a package 'curvyBox' that inherits
from both.
Further suppose that the 'square' package contains a 'square.rect'
module, and a 'square.fill' module, and 'circle' contains a
'circle.curve' module, and a 'circle.fill' module. Because of
the way the Python package '__path__' attribute works, package
inheritance won't combine the '.fill' modules; instead, it will
pick the first '.fill' module found.
To solve this, we could create a 'curvyBox.fill' module that inherited
from both 'square.fill' and 'circle.fill'. But if there are many such
modules or subpackages, and they will be empty but for '__bases__', we
can use 'declareModule()' to avoid having to create individual
subdirectories and '.py' files.
This can be as simple as creating 'curvyBox.py' (or
'curvybox/__init__.py'), and writing this code::
from peak.api import *
__bases__ = '../square', '../circle'
config.declareModule(__name__, 'fill',
bases = ('../../circle/fill',) # relative to 'curvyBox.fill'
)
config.setupModule()
This will add 'circle.fill' to the '__bases__' of 'curvyBox.fill' (which
will be the inherited 'square.fill' module.
Another usage of 'declareModule()' is to patch a third-party module::
import my_additions
config.declareModule('third.party.module', patches=(my_additions,))
"""
if relativePath:
name = joinPath(name, relativePath)
if name in declarations:
if declarations[name] == (bases, patches):
return lazyModule(name) # already declared it this way
raise SpecificationError(
("%s has already been declared differently" % name), patches,
declarations[name])
declarations[name] = bases, patches
def load(module):
if hasattr(module, '__codeList__'): # first load might leave code
del module.__codeList__
plist = patchMap.setdefault(name, [])
for patch in toBases(patches, name):
plist.extend(getCodeListForModule(patch))
module.__bases__ = moduleBases(module, name) + tuple(
toBases(bases, name))
buildModule(module)
# ensure that we are run before any other 'whenImported' hooks
getModuleHooks(name).insert(0, load)
return lazyModule(name)
def getRecord(self, model, id, external=False):
if self.modelIrModelData == None:
self.setIrModelDataModel()
return getattr(lazyModule('models.' + model), model)().getRecord(id, external)
import sys
if not sys.platform.startswith('win'):
# Importing from gui.native.win on other platforms should never happen.
assert 0
from peak.util.imports import lazyModule
dockconstants = lazyModule('gui.native.win.dockconstants')
winhelpers = lazyModule('gui.native.win.winhelpers')
process = lazyModule('gui.native.win.process')
toplevel = lazyModule('gui.native.win.toplevel')
winconstants = lazyModule('gui.native.win.winconstants')
winpaths = lazyModule('gui.native.win.winpaths')
winutil = lazyModule('gui.native.win.winutil')
appbar = lazyModule('gui.native.win.appbar')
'write_dot', 'read_dot',
'graphviz_layout',
'pygraphviz_layout']
import os
import sys
import networkx
from networkx.utils import _get_fh,is_string_like
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
pygraphviz=lazyModule('pygraphviz')
def from_agraph(A,create_using=None):
"""Return a NetworkX Graph or DiGraph from a PyGraphviz graph.
Parameters
----------
A : PyGraphviz AGraph
A graph created with PyGraphviz
create_using : NetworkX graph class instance
The output is created using the given graph class instance
Examples
--------
'''
This file will contain all platform-specific extensions or method replacements to wx API,
such as overriding wx.LaunchDefaultBrowser on Windows or adding wx.Window.Cut method.
'''
from peak.util.imports import lazyModule, whenImported
wx = lazyModule('wx')
os = lazyModule('os')
wintypes = lazyModule('ctypes.wintypes')
from threading import Thread
from logging import getLogger; log = getLogger('winextensions')
import traceback
def browse(url):
'Opens "url" in the default web browser.'
def go():
try:
os.startfile(url)
except WindowsError:
if hasattr(traceback, 'print_exc_once'):
traceback.print_exc_once()
else:
traceback.print_exc()
log.error('could not open browser for url: %r', url)
_fire_browser_error_popup()
# reenable once we have advanced prefs
t = Thread(target=go)
t.setDaemon(True)
'''
A Jabber connection to the Digsby server.
'''
from __future__ import with_statement
from peak.util.imports import lazyModule
import datetime
from digsby.loadbalance import DigsbyLoadBalanceAPI, DigsbyLoadBalanceManager
callbacks = lazyModule('util.callbacks')
mapping = lazyModule('util.primitives.mapping')
funcs = lazyModule('util.primitives.funcs')
error_handling = lazyModule('util.primitives.error_handling')
hook_util = lazyModule('util.hook_util')
util_threads = lazyModule('util.threads')
import common
import sys, traceback
from common import pref, netcall
from hashlib import sha256
import jabber
from jabber import JID
from pyxmpp.presence import Presence
from pyxmpp.roster import RosterItem
from operator import itemgetter
import digsby
from .digsbybuddy import DigsbyBuddy
import random
import string
import blobs
import simplejson
from logging import getLogger
""" goulash.docs
"""
import os
import shutil
import addict
from fabric import api
from fabric.colors import red
from peak.util.imports import lazyModule
fileserver = lazyModule('goulash.fileserver')
inspect = lazyModule('goulash._inspect')
boiler = lazyModule('goulash.boiler')
from goulash._os import copy_tree
from goulash.decorators import require_bin
from goulash.version import __version__ as version
def _get_ctx(args):
args.docroot = os.path.abspath(args.docroot)
DOCS_ROOT = args.docroot
SRC_ROOT = os.path.dirname(args.docroot)
DOCS_URL = 'http://localhost:8000'
DOCS_API_ROOT = os.path.join(DOCS_ROOT, 'api')
DOCS_SITE_DIR = os.path.join(DOCS_ROOT, 'site')
PROJECT_NAME = inspect._main_package(
SRC_ROOT, default=os.path.dirname(os.path.abspath(SRC_ROOT)))
ctx = locals().copy()
ctx.pop('args')
return ctx
"""
##########################################################################
## Imports
##########################################################################
from operator import itemgetter
from collections import defaultdict, Counter
from cloudscope.utils.statistics import mean, median
from cloudscope.utils.strings import snake_case
from cloudscope.exceptions import BadValue
from peak.util.imports import lazyModule
# Perform lazy loading of vizualiation libraries
pd = lazyModule('pandas')
##########################################################################
## Time Series Handlers
##########################################################################
class TimeSeriesAggregator(object):
"""
This complex class can handle the results time series data by key. A
single instance is a callable that takes a key and an iterable of values,
it then routes the value to the appropriate handler based on the key and
returns a dictionary of the aggregates computed by key.
If no handler is associated with the key, then by default it just counts
the number of items in the time series (len). No exceptions are raised.
"""
Utilities for visualizing the topology with communications results.
"""
##########################################################################
## Imports
##########################################################################
from .analysis import aggregator
from operator import add
from collections import defaultdict
from peak.util.imports import lazyModule
from cloudscope.exceptions import BadValue
# Perform lazy loading of vizualiation libraries
gt = lazyModule('graph_tool.all')
np = lazyModule('numpy')
nx = lazyModule('networkx')
##########################################################################
## Helper Functions
##########################################################################
def merge(dicts):
"""
Creates a single dictionary from a list of dictionaries via update.
"""
obj = {}
for d in dicts:
obj.update(d)
from interfaces import *
from transactions import *
from data_managers import *
from connections import *
from caches import *
from lazy_loader import *
from peak.util.imports import lazyModule
xmi = lazyModule('peak.storage.xmi')
del lazyModule
def DMFor(*classes):
from peak.api import config
return config.ProviderOf(IDataManager, *classes)
""" smashlib.util.ipy
import shortcuts for ipython. this also might help to keep
smashlib in sync with changing ipython target versions?
"""
import re
import keyword
from IPython.utils.coloransi import TermColors
from goulash.cache import MWT
from peak.util.imports import lazyModule
logging = lazyModule('smashlib._logging')
r_cmd = re.compile('^[\w-]+$')
def green(txt):
return TermColors.Green + txt + TermColors.Normal
def uninstall_prefilter(HandlerOrCheckerClass):
""" uninstalls argument from running IPython instance,
where the argument may be either a class describing either
a prefilter Handler or a Checker.
"""
# are singletons involved here? not sure we can use
# manager.unregister_handler() etc, since it does an
# instance check instead of a class check.
ip = get_ipython()
# uninstall if handler
handlers = ip.prefilter_manager.handlers
for handler_name, handler in handlers.items():
"""Integration/acceptance tests for SEF.SimpleModel, etc."""
from unittest import TestCase, makeSuite, TestSuite
from peak.api import *
from peak.model.queries import *
from peak.util.imports import lazyModule
from peak.tests import testRoot
UML13 = lazyModule('peak.metamodels.UML13')
class UML_DM(storage.xmi.DM):
metamodel = UML13
UML13 = UML13
Data_Types = binding.Obtain('UML13/Foundation/Data_Types')
Multiplicity = binding.Obtain('Data_Types/Multiplicity')
MultiplicityRange = binding.Obtain('Data_Types/MultiplicityRange')
Package = binding.Obtain('UML13/Model_Management/Package')
Class = binding.Obtain('UML13/Foundation/Core/Class')
class UMLTest(TestCase):
def setUp(self):
self.m = m = UML_DM(testRoot())
self.pkg = m.Package()
def checkNameSet(self):
from fileutil import *
def soupify(
*a, **k
): #this method exists so that BeautifulSoup isn't imported until needed.
import BeautifulSoup
return BeautifulSoup.BeautifulSoup(*a, **k)
import urllib2_file #side effects
import proxy_settings #side effects
#from ie import IEEvents, IEBrowser, JavaScript, GetIE
observe = lazyModule('util.observe')
### SOME MONKEYPATCHING
import rfc822
__old_init = rfc822.Message.__init__
__old_str = rfc822.Message.__str__
def __init__(self, fp, *a, **k):
if isinstance(fp, basestring):
from cStringIO import StringIO
return __old_init(self, StringIO(fp), *a, **k)
else:
return __old_init(self, fp, *a, **k)
from peak.util.imports import lazyModule
from util.primitives import odict
import struct
util = lazyModule('util')
auxencodings = lazyModule('util.auxencodings')
import sys
import array
import logging
import string
from collections import defaultdict
import oscar
log = logging.getLogger('oscar.util')
flagged = lambda f, v: f&v==f
len_to_fmt = {0: '', 1: 'B',
2: 'H', 4: 'I',
8: 'Q', 16:'16s',}
def lowerstrip(s):
return s.lower().replace(' ','')
def tflv(type_, flags=1, data=''):
return struct.pack('!HBB', type_, flags, len(data)) + data
def tflv_list(*tflvs): return ''.join(tflv(*t) for t in tflvs)
def tlv(type_, length=0, value=0):
import cPickle
import codecs
import locale
import string
import sys
import time
from networkx.utils import is_string_like, _get_fh
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
yaml = lazyModule('yaml')
def write_yaml(G, path, default_flow_style=False, **kwds):
"""Write graph G in YAML text format to path.
See http://www.yaml.org
"""
fh = _get_fh(path, mode='w')
yaml.dump(G, fh, default_flow_style=default_flow_style, **kwds)
def read_yaml(path):
"""Read graph from YAML format from path.
__all__ = ['circular_layout',
'random_layout',
'shell_layout',
'spring_layout',
'spectral_layout',
'fruchterman_reingold_layout']
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
np=lazyModule('numpy')
#linalg=lazyModule('scipy.sparse.linalg')
#spdiags=lazyModule('scipy.sparse.spdiags')
#eigen_symmetric=lazyModule('scipy.sparse.linalg.eigen_symmetric')
def random_layout(G,dim=2):
n=len(G)
pos=np.asarray(np.random.random((n,dim)),dtype=np.float32)
return dict(zip(G,pos))
def circular_layout(G, dim=2, scale=1):
# dim=2 only
"""Position nodes on a circle.
Parameters
# ID: tree.py [] [email protected] $ """ Utility module that implements a Tree data structure. """ ########################################################################## ## Imports ########################################################################## from __future__ import division from peak.util.imports import lazyModule # Lazy load visualizations gt = lazyModule('graph_tool.all') ########################################################################## ## Trees ########################################################################## class Tree(object): """ A Tree object is essentially a label and a list of children that can themselves be Tree objects. Trees implement bidirectionality with pointers to both their parent and the children. Any Tree without a parent is considered to be a root node. Trees can also maintain any arbitrary data behond their label. """
import threading
import util.urllib2_file
import simplejson
from pprint import pformat
from pstats import Stats
from util import program_dir, traceguard, threaded, RepeatTimer
from common import profile
from prefs.prefsdata import inflate
from traceback import print_exc, format_exc
from operator import attrgetter
from hashlib import sha256
from peak.util.imports import lazyModule
gui_native = lazyModule('gui.native')
LOGFILE_MAX_BYTES = 9 * 2**20
rep_map = {'no':0,
'yes':1,
'unknown':3}
ZIPFILE_KEY = ('f', 'datafile.zip')
from functools import partial
default_priority = 100 # lower = first
DESCRIPTION_LIMIT = 10000
__all__ = [
'from_whatever', 'from_dict_of_dicts', 'to_dict_of_dicts',
'from_dict_of_lists', 'to_dict_of_lists', 'from_edgelist', 'to_edgelist',
'from_numpy_matrix', 'to_numpy_matrix', 'from_scipy_sparse_matrix',
'to_scipy_sparse_matrix'
]
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
numpy = lazyModule('numpy')
scipy = lazyModule('scipy')
sparse = lazyModule('scipy.sparse')
def _prep_create_using(create_using):
"""
Return a graph object ready to be populated.
If create_using is None return the default (just networkx.Graph())
If create_using.clear() works, assume it returns a graph object.
Otherwise raise an exception because create_using is not a networkx graph.
"""
if create_using is None:
G = networkx.Graph()
""" kinbaku._ast
"""
import compiler
from StringIO import StringIO
import sourcecodegen
from peak.util.imports import lazyModule
from kinbaku._sourcecodegen import generate_code
from kinbaku._types import BadDotPath
core = lazyModule('kinbaku.core')
node_has_lineno = lambda node: hasattr(node,'lineno')
node_is_function = lambda node: isinstance(node,compiler.ast.Function)
node_is_class = lambda node: isinstance(node,compiler.ast.Class)
node_is_module = lambda node: isinstance(node,compiler.ast.Module)
from pythoscope.store import code_of # ?
def src2stringio(src_code):
""" """
fhandle = StringIO()
fhandle.write(src_code)
fhandle.seek(0)
return fhandle
def walk(node, parent=None, lineage=[],
test=None, results={}, callback=None):
""" walker for ast rooted at <node>
callback will be invoked for node,parent,lineage
from peak.core import __all__
__all__ = __all__[:] + [
'commands',
'events',
'logs', #'net', 'query',
'running',
'security',
'storage',
'web',
]
# Convenience features
from peak.util.imports import lazyModule
commands = lazyModule('peak.running.commands')
events = lazyModule('peak.events.api')
logs = lazyModule('peak.running.logs')
#net = lazyModule('peak.net.api')
#query = lazyModule('peak.query.api')
running = lazyModule('peak.running.api')
security = lazyModule('peak.security.api')
storage = lazyModule('peak.storage.api')
web = lazyModule('peak.web.api')
# This is here so that 'peak help iif' will return something useful.
# It is not actually exported from here! 'config.ini_files' imports it
# directly, so it'll be available from .ini files.
def iif(cond, Then, Else):
__all__ = ['from_whatever',
'from_dict_of_dicts', 'to_dict_of_dicts',
'from_dict_of_lists', 'to_dict_of_lists',
'from_edgelist', 'to_edgelist',
'from_numpy_matrix', 'to_numpy_matrix',
'from_scipy_sparse_matrix', 'to_scipy_sparse_matrix']
import networkx
try:
from peak.util.imports import lazyModule
except:
from networkx.util.imports import lazyModule
numpy=lazyModule('numpy')
scipy=lazyModule('scipy')
sparse=lazyModule('scipy.sparse')
def _prep_create_using(create_using):
"""
Return a graph object ready to be populated.
If create_using is None return the default (just networkx.Graph())
If create_using.clear() works, assume it returns a graph object.
Otherwise raise an exception because create_using is not a networkx graph.
"""
if create_using is None:
G=networkx.Graph()
else:
from peak.util.imports import lazyModule
from pyxmpp.utils import from_utf8
from pyxmpp.objects import StanzaPayloadObject
from pyxmpp.xmlextra import get_node_ns_uri
from digsby.widgets import DIGSBY_WIDGETS_NS
from hashlib import sha256
from util import callsback
from digsby.web import digsby_webget
from logging import getLogger
log = getLogger('digsby.widget')
skin = lazyModule('gui.skin')
from util.xml_tag import tag
from urllib2 import urlopen
from urllib import urlencode
from common import profile
from util.net import UrlQuery
import wx
def iswidget(buddy):
'Returns True if the given buddy is from a webpage widget.'
return hasattr(buddy, 'jid') and buddy.jid.domain == 'guest.digsby.org'
def get_local_swf():
return skin.resourcedir() / 'widget' / 'digsby_widget.swf'
"""
##########################################################################
## Imports
##########################################################################
from operator import itemgetter
from collections import defaultdict, Counter
from cloudscope.utils.statistics import mean, median
from cloudscope.utils.strings import snake_case
from cloudscope.exceptions import BadValue
from peak.util.imports import lazyModule
# Perform lazy loading of vizualiation libraries
pd = lazyModule('pandas')
##########################################################################
## Time Series Handlers
##########################################################################
class TimeSeriesAggregator(object):
"""
This complex class can handle the results time series data by key. A
single instance is a callable that takes a key and an iterable of values,
it then routes the value to the appropriate handler based on the key and
returns a dictionary of the aggregates computed by key.
If no handler is associated with the key, then by default it just counts
the number of items in the time series (len). No exceptions are raised.
""" ixle.heuristics.nlp
natural language processing heuristics
"""
from collections import OrderedDict
import nltk
from ixle.python import ope
from .base import H, Heuristic
from ixle.schema import Item
from peak.util.imports import lazyModule
heuristics = lazyModule('ixle.heuristics')
class freq_dist(Heuristic):
""" this heuristic returns a dictionary of {token:frequency}
for this item whenever
1) the item exists (or is mounted), AND
2) the is_text(item) heuristic is true
NOTE:
this will require nltk and perhaps some of the nltk
data, depending on how the distro ships things.
if you seem to be missing tokenizers, try running
this from console:
>>> import nltk;
# # ID: viz.py [] [email protected] $ """ Helper functions for creating output vizualiations from simulations. """ ########################################################################## ## Imports ########################################################################## from gvas.config import settings from peak.util.imports import lazyModule # Perform lazy loading of vizualiation libraries sns = lazyModule('seaborn') plt = lazyModule('matplotlib.pyplot') np = lazyModule('numpy') pd = lazyModule('pandas') ########################################################################## ## Helper Functions ########################################################################## def configure(**kwargs): """ Sets various configurations for Seaborn from the settings or arguments. """ # Get configurations to do modifications on them. style = kwargs.pop('style', settings.vizualization.style)
'''
A Jabber connection to the Digsby server.
'''
from __future__ import with_statement
from peak.util.imports import lazyModule
import datetime
from digsby.loadbalance import DigsbyLoadBalanceAPI, DigsbyLoadBalanceManager
callbacks = lazyModule('util.callbacks')
mapping = lazyModule('util.primitives.mapping')
funcs = lazyModule('util.primitives.funcs')
error_handling = lazyModule('util.primitives.error_handling')
hook_util = lazyModule('util.hook_util')
util_threads = lazyModule('util.threads')
import common
import sys, traceback
from common import pref, netcall
from hashlib import sha256
import jabber
from jabber import JID
from pyxmpp.presence import Presence
from pyxmpp.roster import RosterItem
from operator import itemgetter
import digsby
from .digsbybuddy import DigsbyBuddy
import random
import string
import blobs
import simplejson
from logging import getLogger
Helper functions for creating output vizualiations from simulations.
"""
##########################################################################
## Imports
##########################################################################
from operator import itemgetter
from collections import defaultdict
from cloudscope.config import settings
from peak.util.imports import lazyModule
from cloudscope.colors import ColorMap
from networkx.readwrite import json_graph
# Perform lazy loading of vizualiation libraries
nx = lazyModule('networkx')
gt = lazyModule('graph_tool.all')
sns = lazyModule('seaborn')
plt = lazyModule('matplotlib.pyplot')
np = lazyModule('numpy')
pd = lazyModule('pandas')
##########################################################################
## Helper Functions
##########################################################################
def configure(**kwargs):
"""
Sets various configurations for Seaborn from the settings or arguments.
"""
"""Runtime environment tools for logging, locking, process control, etc.
Please see the individual modules for useful classes, etc."""
from interfaces import *
from peak.util.imports import lazyModule
commands = lazyModule('peak.running.commands')
del lazyModule
Objects for computing Statistics and probabilities (reused from Ben's old code)
"""
##########################################################################
## Imports
##########################################################################
import math
import json
from itertools import islice
from collections import Counter
from peak.util.imports import lazyModule
# Lazy loading of optional dependencies
pylab = lazyModule('pylab')
##########################################################################
## Statistical computation functions
##########################################################################
def mean(data):
"""
TODO: if Numpy becomes a dependency, change this to a Numpy computation.
"""
# Don't do anything without data
if not data: return None
data = list(map(float, data))
if data:
return sum(data) / len(data)
# ID: tree.py [] [email protected] $ """ Utility module that implements a Tree data structure. """ ########################################################################## ## Imports ########################################################################## from __future__ import division from peak.util.imports import lazyModule # Lazy load visualizations gt = lazyModule("graph_tool.all") ########################################################################## ## Trees ########################################################################## class Tree(object): """ A Tree object is essentially a label and a list of children that can themselves be Tree objects. Trees implement bidirectionality with pointers to both their parent and the children. Any Tree without a parent is considered to be a root node. Trees can also maintain any arbitrary data behond their label.
'''
This file will contain all platform-specific extensions or method replacements to wx API,
such as overriding wx.LaunchDefaultBrowser on Windows or adding wx.Window.Cut method.
'''
from peak.util.imports import lazyModule, whenImported
wx = lazyModule('wx')
os = lazyModule('os')
wintypes = lazyModule('ctypes.wintypes')
from threading import Thread
from logging import getLogger
log = getLogger('winextensions')
import traceback
def browse(url):
'Opens "url" in the default web browser.'
def go():
try:
os.startfile(url)
except WindowsError:
if hasattr(traceback, 'print_exc_once'):
traceback.print_exc_once()
else:
traceback.print_exc()
log.error('could not open browser for url: %r', url)
_fire_browser_error_popup()
# reenable once we have advanced prefs
'''
Registers auxillary encodings in the codecs module.
>>> 'x\x9cK\xc9L/N\xaa\x04\x00\x08\x9d\x02\x83'.decode('zip')
'digsby'
'''
from peak.util.imports import lazyModule
sys = lazyModule('sys')
warnings = lazyModule('warnings')
locale = lazyModule('locale')
collections = lazyModule('collections')
urllib = lazyModule('urllib')
urllib2 = lazyModule('urllib2')
codecs = lazyModule('codecs')
StringIO = lazyModule('StringIO')
zipfile = lazyModule('zipfile')
gzip = lazyModule('gzip')
htmlentitydefs = lazyModule('htmlentitydefs')
base64 = lazyModule('base64')
#pylzma = lazyModule('pylzma')
HAVE_LZMA = False #until proven otherwise
ENCODE_LZMA = False
__simplechars_enc = {
ord('<') : 'lt',
ord('>') : 'gt',
#ord("'") : 'apos',
ord('"') : 'quot',
from peak.util.imports import lazyModule
from pyxmpp.utils import from_utf8
from pyxmpp.objects import StanzaPayloadObject
from pyxmpp.xmlextra import get_node_ns_uri
from digsby.widgets import DIGSBY_WIDGETS_NS
from hashlib import sha256
from util import callsback
from digsby.web import digsby_webget
from logging import getLogger; log = getLogger('digsby.widget')
skin = lazyModule('gui.skin')
from util.xml_tag import tag
from urllib2 import urlopen
from urllib import urlencode
from common import profile
from util.net import UrlQuery
import wx
def iswidget(buddy):
'Returns True if the given buddy is from a webpage widget.'
return hasattr(buddy, 'jid') and buddy.jid.domain == 'guest.digsby.org'
def get_local_swf():
return skin.resourcedir() / 'widget' / 'digsby_widget.swf'
'protocols',
'dispatch',
'NOT_GIVEN',
'NOT_FOUND',
'Items', # Primitives
'PropertyName',
'binding',
'config',
'model',
'naming', # Core
'exceptions',
]
from peak.util.imports import lazyModule, whenImported
binding = lazyModule('peak.binding.api')
config = lazyModule('peak.config.api')
model = lazyModule('peak.model.api')
naming = lazyModule('peak.naming.api')
exceptions = lazyModule('peak.exceptions')
from peak.util.symbols import NOT_GIVEN, NOT_FOUND
def Items(mapping=None, **kwargs):
"""Convert 'mapping' and/or 'kwargs' into a list of '(key,val)' items
Key/value item lists are often easier or more efficient to manipulate
than mapping objects, so PEAK API's will often use such lists as
a preferred parameter format. Sometimes, however, the syntactic sugar
of keyword items, possibly in combination with an existing mapping
