def load_snapshot(snapshot_name):
"""
Load the simulation stored in snapshot_name.
"""
# unpickling the PicklableClassAttributes() executes startup_commands and
# sets PO class parameters.
snapshot_name = param.resolve_path(snapshot_name)
# If it's not gzipped, open as a normal file.
try:
snapshot = gzip.open(snapshot_name, 'r')
snapshot.read(1)
snapshot.seek(0)
except (IOError, NameError):
snapshot = open(snapshot_name, 'r')
try:
pickle.load(snapshot)
except ImportError:
# CEBALERT: Support snapshots where the unpickling support
# (UnpickleEnvironmentCreator) cannot be found because the
# support itself was moved from topo.command.basic to
# topo.command.__init__! Was it a bad idea to have the support
# code loaded via an object?
sys.modules['topo.command.basic'] = topo.command
# Could instead set find_global on cPickle.Unpickler (could
# support all import changes that way, as alternative to what
# we currently do), but I'm reluctant to mess with cPickle's
# default way of finding things. (Also it would be specific to
# cPickle; would be different for pickle.)
snapshot.seek(0)
try:
pickle.load(snapshot)
except:
import traceback
m = """
Snapshot could not be loaded.
Please file a support request via topographica.org.
Loading error:
%s
""" % traceback.format_exc()
param.Parameterized(name="load_snapshot").warning(m)
snapshot.close()
# Restore subplotting prefs without worrying if there is a
# problem (e.g. if topo/analysis/ is not present)
try:
from topo.analysis.featureresponses import Subplotting
Subplotting.restore_subplots()
except:
p = param.Parameterized(name="load_snapshot")
p.message("Unable to restore Subplotting settings")
def setUp(self):
self.some_pos = [param.Parameterized(),param.Parameterized(),
param.Parameterized()]
self.testpo1 = TestPO()
self.testpo1.params()['osp'].objects = self.some_pos
self.testpo2 = TestPO()
self.testpo1.params()['osp'].objects = self.some_pos
self.toplevel = Tkinter.Toplevel()
self.f = tk.ParametersFrameWithApply(self.toplevel,self.testpo1)
def matrix_hsv_to_rgb(hMapArray, sMapArray, vMapArray):
"""
First matrix sets the Hue (Color).
Second marix sets the Sauration (How much color)
Third matrix sets the Value (How bright the pixel will be)
The three input matrices should all be the same size, and have
been normalized to 1. There should be no side-effects on the
original input matrices.
"""
shape = hMapArray.shape
rmat = array(hMapArray, Float)
gmat = array(sMapArray, Float)
bmat = array(vMapArray, Float)
## This code should never be seen. It means that calling code did
## not take the precaution of clipping the input matrices.
if max(rmat.ravel()) > 1 or max(gmat.ravel()) > 1 or max(bmat.ravel()) > 1:
param.Parameterized().warning(
'HSVBitmap inputs exceed 1. Clipping to 1.0')
if max(rmat.ravel()) > 0: rmat = clip(rmat, 0.0, 1.0)
if max(gmat.ravel()) > 0: gmat = clip(gmat, 0.0, 1.0)
if max(bmat.ravel()) > 0: bmat = clip(bmat, 0.0, 1.0)
# List comprehensions were not used because they were slower.
for j in range(shape[0]):
for i in range(shape[1]):
rgb = hsv_to_rgb(rmat[j, i], gmat[j, i], bmat[j, i])
rmat[j, i] = rgb[0]
gmat[j, i] = rgb[1]
bmat[j, i] = rgb[2]
return (rmat, gmat, bmat)
def make_template_plot(channels,
sheet_views,
density=None,
plot_bounding_box=None,
normalize='None',
name='None',
range_=False):
"""
Factory function for constructing a Plot object whose type is not yet known.
Typically, a TemplatePlot will be constructed through this call, because
it selects the appropriate type automatically, rather than calling
one of the Plot subclasses automatically. See TemplatePlot.__init__ for
a description of the arguments.
"""
if _sane_plot_data(channels, sheet_views):
plot_types = [SHCPlot, RGBPlot, PalettePlot, MultiOrPlot]
for pt in plot_types:
plot = pt(channels,
sheet_views,
density,
plot_bounding_box,
normalize,
name=name,
range_=range_)
if plot.bitmap is not None or range_ is None:
# range_ is None means we're calculating the range
return plot
param.Parameterized(name="make_template_plot").verbose(
'No', name, 'plot constructed for this Sheet')
return None
def install(snapshot_release,snapshot_version=None):
snapshot_version = _get_version(snapshot_release,snapshot_version)
param.Parameterized().debug("Snapshot is from release %s (r%s)"%(snapshot_release,snapshot_version))
SnapshotSupport.apply_external_patches()
SnapshotSupport.apply_support(snapshot_version)
def _get_version(snapshot_release, snapshot_version):
found_version = False
if snapshot_version is not None:
try: # to detect the passed version
snapshot_version = snapshot_version.split(":")[0]
snapshot_version = snapshot_version.split("M")[0]
except AttributeError: # the version is a tuple, thus it's from git
snapshot_version = "%02d%02d%02d%05d" % snapshot_version
if len(snapshot_version) > 0:
try:
snapshot_version = int(snapshot_version)
found_version = True
except ValueError:
pass
if not found_version:
snapshot_version = releases[snapshot_release]
param.Parameterized().debug(
"No version could be detected for this snapshot; assuming version of release %s (i.e. %s)."
% (snapshot_release, snapshot_version))
return snapshot_version
def test_server_session_info():
with config.set(session_history=-1):
html = Markdown('# Title')
server = serve(html, port=5009, threaded=True, show=False)
# Wait for server to start
time.sleep(1)
requests.get("http://localhost:5009/")
assert state.session_info['total'] == 1
assert len(state.session_info['sessions']) == 1
sid, session = list(state.session_info['sessions'].items())[0]
assert session['user_agent'].startswith('python-requests')
assert state.session_info['live'] == 0
doc = list(html._documents.keys())[0]
session_context = param.Parameterized()
session_context._document = doc
session_context.id = sid
doc._session_context = session_context
state.curdoc = doc
state._init_session(None)
assert state.session_info['live'] == 1
server.stop()
state.curdoc = None
html._server_destroy(session_context)
assert state.session_info['live'] == 0
def test_template_session_destroy(document, comm):
tmplt = Template(template)
widget = FloatSlider()
row = Row('A', 'B')
tmplt.add_panel('A', widget)
tmplt.add_panel('B', row)
tmplt._init_doc(document, comm, notebook=True)
session_context = param.Parameterized()
session_context._document = document
session_context.id = 'Some ID'
assert len(widget._models) == 2
assert len(row._models) == 2
assert len(row[0]._models) == 2
assert len(row[1]._models) == 2
for cb in document.session_destroyed_callbacks:
cb(session_context)
assert len(widget._models) == 0
assert len(row._models) == 0
assert len(row[0]._models) == 0
assert len(row[1]._models) == 0
def find_module(self, fullname, path=None):
if fullname == self.fullname:
param.Parameterized().message("%s imported as %s"%(self.module.__name__,self.fullname))
faker = _ModuleFaker(self.module)
faker.path = path
return faker
return None
def test_object_selector_parameter(self):
"""
Test that ObjectSelectorParameter representation works.
"""
some_pos = [
param.Parameterized(name='cat'),
param.Parameterized(name='rat'),
param.Parameterized(name='bat')
]
osp_param = self.f.get_parameter_object('osp')
osp_param.objects = some_pos
#self.f.r.default = some_pos[0]
self.f.pack_param(
'osp'
) # have to pack AFTER populating range for OptionMenu widget to work (see ALERT in tkparameterizedobject.py)
# (otherwise, could do the following:
## f = SomeFrame(Toplevel())
## f.pack_param('r')
## f.initialize_ranged_parameter('r',
## [Parameterized(name='cat'),Parameterized(name='rat'),Parameterized(name='bat')])
self.assertEqual(self.f.translators['osp'].string2object('cat'),
some_pos[0])
self.assertEqual(self.f.translators['osp'].string2object('rat'),
some_pos[1])
self.assertEqual(self.f.translators['osp'].string2object('bat'),
some_pos[2])
gnat = param.Parameterized(name='gnat')
osp_param.objects.append(gnat)
self.f.unpack_param('osp')
self.f.pack_param(
'osp') # again, note the need to pack after updating range.
## self.f.initialize_ranged_parameter('r',Parameterized)
self.assertEqual(self.f.translators['osp'].string2object('gnat'), gnat)
self.assertEqual(self.f._object2string('osp', some_pos[0]), 'cat')
self.assertEqual(self.f._object2string('osp', some_pos[1]), 'rat')
self.assertEqual(self.f._object2string('osp', some_pos[2]), 'bat')
# Simulate a GUI set
self.f._tkvars['osp'].set('bat')
self.assertEqual(self.f.osp, some_pos[2])
def apply_support(version_to_support):
global support
# apply oldest to newest
for version in sorted(support.keys())[::-1]:
if version_to_support < version:
param.Parameterized().message("Applying legacy support for change r%s"%version)
support[version]()
def default_input_sheet():
"""Returns the first GeneratorSheet defined, for use as a default value."""
sheets=topo.sim.objects(GeneratorSheet).values()
if len(sheets)<1:
raise ValueError("Unable to find a suitable input sheet.")
sht=sheets[0]
if len(sheets)>1:
param.Parameterized().message("Using input sheet %s." % sht.name)
return sht
def find_module(self, fullname, path=None):
if fullname == 'gmpy' or fullname.startswith('gmpy.'):
import param
param.Parameterized().warning(
'Module "gmpy" is not available. gmpy.mpq is provided by using fixedpoint.FixedPoint.'
)
g = gmpyFaker()
g.path = path
return g
return None
def default_measureable_sheet():
"""Returns the first sheet for which measure_maps is True (if any), or else the first sheet, for use as a default value."""
sheets = [s for s in topo.sim.objects(Sheet).values()
if hasattr(s,'measure_maps') and s.measure_maps]
if len(sheets)<1:
sheets = [s for s in topo.sim.objects(Sheet).values()]
if len(sheets)<1:
raise ValueError("Unable to find a suitable measureable sheet.")
sht=sheets[0]
if len(sheets)>1:
param.Parameterized().message("Using sheet %s." % sht.name)
return sht
def test_params(self):
"""Basic tests of params() method."""
# CB: test not so good because it requires changes if params
# of PO are changed
assert 'name' in param.Parameterized.param.params()
assert len(param.Parameterized.param.params()) in [1,2]
## check for bug where subclass Parameters were not showing up
## if params() already called on a super class.
assert 'inst' in TestPO.param.params()
assert 'notinst' in TestPO.param.params()
## check caching
assert param.Parameterized.param.params() is param.Parameterized().param.params(), "Results of params() should be cached." # just for performance reasons
def install(snapshot_release, snapshot_version=None):
# CEB: I think there's no simple way to tell what "version" of
# Topographica a snapshot comes from. When you're running
# Topographica from svn, you can try topo.version, but you'll
# get things like 11499:11503 or 11499M. If you use git,
# you'll see "exported". Therefore, we can't always have
# fine-grained control over what's loaded. We can at least use
# the release number for coarse-grained control, though.
snapshot_version = _get_version(snapshot_release, snapshot_version)
param.Parameterized().debug("Snapshot is from release %s (r%s)" %
(snapshot_release, snapshot_version))
SnapshotSupport.apply_external_patches()
SnapshotSupport.apply_support(snapshot_version)
def _find_version():
"""
Return the version tuple, the release number, the git commit, and
whether reading pickle files is allowed (False if no version
information avaliable).
"""
pickle_allowed = True
git_output = "v0.0.0-0-"
(basepath, _) = os.path.split(os.path.abspath(__file__))
try:
git_process = Popen(["git", "describe"],
stdout=PIPE,
stderr=PIPE,
cwd=basepath)
git_output = git_process.communicate()[0].strip()
if git_process.poll():
raise OSError
except OSError, CalledProcessError: #pyflakes:ignore (has to do with Python versions for CalledProcessError)
try:
release_file = open(basepath + "/.release")
git_output = release_file.read()
release_file.close()
except IOError:
param.Parameterized().warning("""\
Unable to determine the version information for this copy of Topographica.
For an official release, the version information is stored in a file
named topo/.release. For a development copy checked out from Git, the
version is requested using "git describe". Neither of these options
was successful, perhaps because Git is not available on this machine.
To work around this problem, either install Git on this machine, or
temporarily use a machine that does have Git and run "topographica
make-release-file", making sure you have write permissions on
Topographica's root directory.
In the meantime, reading and saving snapshots will be disabled,
because version information is necessary for determining how to
interpret saved files.\n\n""")
pickle_allowed = False
git_output = "v0.0.0-0-"
def _get_version(snapshot_release, snapshot_version):
"""
Try to determine a single numerical version for use in looking up
patches in the support dictionary, given a snapshot's declared
release and version.
Because of the variety of different version formats that have been
in use over the different version-control systems over the years,
it's not always possible to make such a mapping. E.g. versions
controlled by SVN would normally return topo.version like 11499,
which is clear, but also sometimes 11499:11503 or 11499M.
Versions from git checkouts of svn source would just say
"exported", while native git versions will have a four-tuple. If
nothing else works, the numerical version associated with the
stated release is used.
"""
found_version = False
if snapshot_version is not None:
try: # to detect the passed version
snapshot_version = snapshot_version.split(":")[0]
snapshot_version = snapshot_version.split("M")[0]
except AttributeError: # the version is a tuple, thus it's from git
snapshot_version = version_int(snapshot_version)
# Convert to integer if snapshot_version contains only digits
if snapshot_version:
try:
snapshot_version = int(snapshot_version)
found_version = True
except ValueError:
pass
if not found_version:
snapshot_version = releases[snapshot_release]
param.Parameterized().debug(
"No version could be detected for this snapshot; assuming version of release %s (i.e. %s)."
% (snapshot_release, snapshot_version))
return snapshot_version
def _get_version(snapshot_release, snapshot_version):
found_version = False
if snapshot_version is not None:
snapshot_version = snapshot_version.split(":")[0]
snapshot_version = snapshot_version.split("M")[0]
if len(snapshot_version) > 0:
try:
snapshot_version = int(snapshot_version)
found_version = True
except ValueError:
pass
if not found_version:
snapshot_version = releases[snapshot_release]
param.Parameterized().debug(
"No version could be detected for this snapshot; assuming version of release %s (i.e. %s)."
% (snapshot_release, snapshot_version))
return snapshot_version
def exec_startup_files():
"""
Execute startup files.
Linux/UNIX/OS X: ~/.topographicarc
Windows: %USERPROFILE%\topographica.ini
"""
# From Bilal: On OS X, ~/Library/Preferences/ is the standard path
# for user-defined params. The filename format (corresponding to
# .ini on windows) is org.topographica.plist, where a plist is an
# XML file. But, many shell-based programs follow the Unix
# convention, so we should be fine doing that.
# Linux/UNIX/OS X:
rcpath = os.path.join(os.path.expanduser("~"), '.topographicarc')
# Windows (ini is convention, and can be double clicked to edit):
inipath = os.path.join(os.path.expandvars("$USERPROFILE"),
'topographica.ini')
for startup_file in (rcpath, inipath):
if os.path.exists(startup_file):
print "Executing user startup file %s" % (startup_file)
execfile(startup_file, __main__.__dict__)
#####
# CEBALERT: locations we used to use on Windows and OS X. Should
# remove after 0.9.8.
# application data on windows
inipath = os.path.join(os.path.expandvars("$APPDATA"), 'Topographica',
'topographica.ini')
# application support on OS X
configpath = os.path.join(os.path.expanduser("~"), "Library",
"Application Support", 'Topographica',
'topographica.config')
for startup_file in (configpath, inipath):
if os.path.exists(startup_file):
param.Parameterized().warning(
"Ignoring %s; location for startup file is %s (UNIX/Linux/Mac OS X) or %s (Windows)."
% (startup_file, rcpath, inipath))
def _tkinter_report_exception(widget):
exc, val = sys.exc_type, sys.exc_value
msg = "(%s) %s"%(exc.__name__,val)
# If the supplied widget has no master, it's probably the Tk
# instance. In that case, resort to the 'last-one-set' hack (see
# CEBALERT "provide a way of allowing other gui components" in
# topo/param/tk.py).
if not widget.master:
widget = tk._last_one_set
stat = None
while (widget is not None and widget.master):
# CEBALERT: should rename all status bars to the same thing
# (status_bar)
if hasattr(widget,'status'):
stat = widget.status
break
elif hasattr(widget,'messageBar'):
stat = widget.messageBar
break
widget = widget.master
if stat is not None:
stat.error('%s'%msg)
else:
topo.guimain.messageBar.error('%s'%msg)
# BK-NOTE: Default is now to display full trace always. Any user
# errors should be caught as special exception cases
# BK-ALERT: Want to raise errors vs print, however this currently crashes ipython.
#raise
param.Parameterized().warning(msg)
import traceback
traceback.print_exc()
def pattern_present(inputs={},
duration=1.0,
plastic=False,
overwrite_previous=False,
apply_output_fns=True):
"""
Present the specified test patterns for the specified duration.
Given a set of input patterns (dictionary of
GeneratorSheetName:PatternGenerator pairs), installs them into the
specified GeneratorSheets, runs the simulation for the specified
length of time, then restores the original patterns and the
original simulation time. Thus this input is not considered part
of the regular simulation, and is usually for testing purposes.
As a special case, if 'inputs' is just a single pattern, and not
a dictionary, it is presented to all GeneratorSheets.
If a simulation is not provided, the active simulation, if one
exists, is requested.
If this process is interrupted by the user, the temporary patterns
may still be installed on the retina.
If overwrite_previous is true, the given inputs overwrite those
previously defined.
If plastic is False, overwrites the existing values of Sheet.plastic
to disable plasticity, then reenables plasticity.
In order to to see the sequence of values presented, use the back arrow
history mechanism in the GUI. Note that the GUI's Activity window must
be open and the display parameter set to true (display=True).
"""
# ensure EPs get started (if pattern_present is called before the simulation is run())
topo.sim.run(0.0)
if not overwrite_previous:
save_input_generators()
if not plastic:
# turn off plasticity everywhere
for sheet in topo.sim.objects(Sheet).values():
sheet.override_plasticity_state(new_plasticity_state=False)
if not apply_output_fns:
for each in topo.sim.objects(Sheet).values():
if hasattr(each, 'measure_maps'):
if each.measure_maps:
each.apply_output_fns = False
# Register the inputs on each input sheet
generatorsheets = topo.sim.objects(GeneratorSheet)
if not isinstance(inputs, dict):
for g in generatorsheets.values():
g.set_input_generator(inputs)
else:
for each in inputs.keys():
if generatorsheets.has_key(each):
generatorsheets[each].set_input_generator(inputs[each])
else:
param.Parameterized().warning(
'%s not a valid Sheet name for pattern_present.' % each)
topo.sim.event_push()
# CBENHANCEMENT: would be nice to break this up for visualizing motion
topo.sim.run(duration)
topo.sim.event_pop()
# turn sheets' plasticity and output_fn plasticity back on if we turned it off before
if not plastic:
for sheet in topo.sim.objects(Sheet).values():
sheet.restore_plasticity_state()
if not apply_output_fns:
for each in topo.sim.objects(Sheet).values():
each.apply_output_fns = True
if not overwrite_previous:
restore_input_generators()
def setUp(self):
super(TestParamOverrides, self).setUp()
self.po = param.Parameterized(name='A',print_level=0)
__version__ = "$Revision$"
import param
from topo.base.sheet import Sheet
from topo.misc.ptz import PTZ
from topo.base.arrayutil import array_argmax
import numpy as np
from PIL import Image
try:
import opencv
except ImportError:
param.Parameterized().warning(
"ptztracker.py classes will not be usable; python-opencv is not available."
)
class PtzTracker(Sheet):
"""
Given an incoming Activity pattern, find the brightest pixel and
output an activity pattern where all but this pixel is set to zero.
Also controls a pan/tilt/zoom camera, instructing it to move so that
the brightest pixel will be in the center of the sheet.
"""
dest_ports = ['Activity']
src_ports = ['Activity']
ratio = param.Number(
Before importing this file, you will probably want to do something
like:
from matplotlib import rcParams
rcParams['backend']='TkAgg'
to select a backend, or else select an appropriate one in your
matplotlib.rc file (if any). There are many backends available for
different GUI or non-GUI uses.
"""
try:
from matplotlib import pylab as plt
except ImportError:
import param
param.Parameterized(name=__name__).warning(
"Could not import matplotlib; module will not be useable.")
from topo.command import ImportErrorRaisingFakeModule
plt = ImportErrorRaisingFakeModule(
"matplotlib") # pyflakes:ignore (try/except import)
import param
import numpy as np
from numpy.fft.fftpack import fft2
from numpy.fft.helper import fftshift
import topo
from topo.base.sheet import Sheet
from topo.base.arrayutil import wrap
from topo.plotting.plot import make_template_plot
def featuremapper_legacy():
# For snapshots saved before 90800300
# Replace PatternPresenter objects with stub
import topo.analysis.featureresponses
import param
class PatternPresenter(param.Parameterized):
def __init__(self):
pass
topo.analysis.featureresponses.PatternPresenter = PatternPresenter
# Move parameters and change them if necessary
duration_lambda = lambda x: param.List(default=[x.default], doc="""
If non-None, pattern_response_fn.duration will be set to this value.""")
apply_output_fns_lambda = lambda x: {'apply_output_fns': x.default}
name_changes = PicklableClassAttributes.param_name_changes
mrc_name_changes = name_changes.get(
'topo.analysis.featureresponses.MeasureResponseCommand',{})
mrc_name_changes.update(
{'duration': ('durations', duration_lambda)})
name_changes['topo.analysis.featureresponses.MeasureResponseCommand']=mrc_name_changes
mrc_moves = PicklableClassAttributes.param_moves.get(
'topo.analysis.featureresponses.MeasureResponseCommand',{})
mrc_moves.update({'apply_output_fns':
('topo.analysis.featureresponses.FeatureResponses','cmd_overrides',apply_output_fns_lambda)})
PicklableClassAttributes.param_moves['topo.analysis.featureresponses.MeasureResponseCommand'] = mrc_moves
fcc_name_changes = name_changes.get(
'topo.analysis.featureresponses.FeatureCurveCommand',{})
fcc_name_changes.update(
{'duration': ('durations', duration_lambda)})
name_changes['topo.analysis.featureresponses.FeatureCurveCommand']=fcc_name_changes
fcc_moves = PicklableClassAttributes.param_moves.get(
'topo.analysis.featureresponses.FeatureCurveCommand',{})
fcc_moves.update({'apply_output_fns':
('topo.analysis.featureresponses.FeatureCurves','cmd_overrides',apply_output_fns_lambda)})
PicklableClassAttributes.param_moves['topo.analysis.featureresponses.FeatureCurveCommand'] = fcc_moves
ppc_name_changes = name_changes.get(
'topo.analysis.featureresponses.PatternPresentingCommand',{})
ppc_name_changes.update(
{'duration': ('durations', duration_lambda),
'sheet_views_prefix': 'measurement_prefix'})
name_changes['topo.analysis.featureresponses.PatternPresentingCommand']=ppc_name_changes
# Move enable_fullmatrix parameter
fr_name_changes = name_changes.get(
'topo.analysis.featureresponses.FeatureResponses',{})
fr_name_changes.update(
{'enable_fullmatrix':'store_fullmatrix'})
name_changes['topo.analysis.featureresponses.FeatureResponses']=fr_name_changes
# Measurement Prefix
fr_name_changes = name_changes.get(
'topo.analysis.featureresponses.FeatureResponses',{})
fr_name_changes.update(
{'enable_fullmatrix':'store_fullmatrix'})
name_changes['topo.analysis.featureresponses.FeatureResponses']=fr_name_changes
# Delete old parameters
old_cmd_params = ('display', 'pattern_presenter', 'generator_sheets',
'input_sheet', 'sheet')
param_no_restore = {'MeasureResponseCommand': old_cmd_params,
'FeatureCurveCommand': old_cmd_params,
'ProjectionSheetMeasurementCommand' : old_cmd_params,
'SingleInputResponseCommand': old_cmd_params,
'measure_rfs': ('sampling_interval', 'sampling_area'),
'unit_tuning_curve': ('x_axis', 'sheet'),
'ReverseCorrelation': old_cmd_params,
'FeatureCurves': ('post_collect_responses_hook'),
'FeatureMaps': ('sheet_views_prefix'),
'measure_latency_preference': old_cmd_params,
'PositionMeasurementCommand': old_cmd_params,
'measure_corner_or_pref': old_cmd_params,
'measure_orientation_contrast': old_cmd_params,
'PatternPresenter': ('contrast_parameter', 'divisions',
'generator_sheets', 'apply_output_fns',
'duration'),
'measure_or_tuning_fullfield': old_cmd_params,
'UnitCurveCommand': old_cmd_params,
'measure_frequency_preference': old_cmd_params,
'SinusoidalMeasureResponseCommand': old_cmd_params,
'measure_log_frequency_preference': old_cmd_params}
PicklableClassAttributes.deleted_params.update(param_no_restore)
# Convert old sheet_views and curve_dict
from topo.misc.attrdict import AttrDict
from topo.base.sheet import Sheet
from holoviews import Matrix, NdMapping
def _set_sheet_views(instance, state):
if state['simulation'] is None:
return None
name = state['_name_param_value']
if not hasattr(state['simulation'], 'views'):
state['simulation'].views = AttrDict()
if name not in state['simulation'].views:
if hasattr(instance, 'views'):
state['views'] = instance.views
else:
state['views'] = AttrDict()
state['simulation'].views[name] = state['views']
views = state['views']
views['maps'] = AttrDict()
views['cfs'] = AttrDict()
views['rfs'] = AttrDict()
views['curves'] = AttrDict()
if 'sheet_views' in state:
svs = state['sheet_views']
for key, sv in svs.items():
data, bounds = sv.view()
new_sv = Matrix(data, bounds)
metadata = dict(dimension_labels=['Time'])
metadata_names = ['cyclic_range', 'precedence',
'row_precedence', 'src_name']
for p in metadata_names:
if hasattr(sv, p):
metadata[p] = getattr(sv, p)
state['views'].maps[key] = NdMapping((sv.timestamp, new_sv),
**metadata)
if 'curve_dict' in state:
old_curves = state['curve_dict']
curves = views['curves']
for key, value in old_curves.items():
key = key.capitalize()
for label, item in value.items():
labels = unit_value(label)
label_name = labels[0].split(' ')[0]
l_val = labels[-1]
if key not in views['curves']:
curves[key] = NdMapping(dimension_labels=['Time'])
for f_val, old_sv in item.items():
timestamp = old_sv.timestamp
curves[key][timestamp] = NdMapping(dimension_labels=[label_name])
if l_val not in curves[key][timestamp].keys():
curves[key][timestamp] [l_val] = NdMapping(dimension_labels=[key],
label=label,
timestamp=old_sv.timestamp)
data, bounds = old_sv.view()
sv = Matrix(data, bounds)
curves[key][timestamp][l_val][f_val] = sv
state.pop('curve_dict', None)
state.pop('sheet_views', None)
preprocess_state(Sheet, _set_sheet_views)
param.Parameterized().warning('Legacy code does not guarantee all '
'measurement parameters have been restored. Make sure measurements are '
'still set up correctly.')
import param
import os
from . import TimeSeries, Spectrogram, PowerSpectrum
from numpy import arange, array, ceil, complex64, cos, exp, fft, flipud, \
float64, floor, hanning, hstack, log, log10, logspace, multiply, \
nonzero, ones, pi, reshape, shape, size, sqrt, sum, tile, zeros
try:
import scikits.audiolab as audiolab
except ImportError:
param.Parameterized().warning(
"audio.py classes will not be usable because scikits.audiolab is not available."
)
class AudioFile(TimeSeries):
"""
Requires an audio file in any format accepted by audiolab (wav, aiff, flac).
"""
time_series = param.Array(precedence=(-1))
sample_rate = param.Number(precedence=(-1))
filename = param.Filename(default='sounds/complex/daisy.wav',
doc="""
File path (can be relative to Param's base path) to an audio file.
The audio can be in any format accepted by audiolab, e.g. WAV, AIFF, or FLAC."""
def __call__(self, inputs={}, outputs=[], **params_to_override):
p = ParamOverrides(self, dict(params_to_override, inputs=inputs))
# ensure EPs get started (if pattern_response is called before the
# simulation is run())
topo.sim.run(0.0)
if p.restore_state:
topo.sim.state_push()
if not p.overwrite_previous:
save_input_generators()
if not p.plastic:
# turn off plasticity everywhere
for sheet in topo.sim.objects(Sheet).values():
sheet.override_plasticity_state(new_plasticity_state=False)
if not p.apply_output_fns:
for each in topo.sim.objects(Sheet).values():
if hasattr(each, 'measure_maps'):
if each.measure_maps:
each.apply_output_fns = False
# Register the inputs on each input sheet
generatorsheets = topo.sim.objects(GeneratorSheet)
if not isinstance(p.inputs, dict):
for g in generatorsheets.values():
g.set_input_generator(p.inputs)
else:
for each in p.inputs.keys():
if generatorsheets.has_key(each):
generatorsheets[each].set_input_generator(p.inputs[each])
else:
param.Parameterized().warning(
'%s not a valid Sheet name for pattern_present.' % each)
if p.restore_events:
topo.sim.event_push()
durations = np.diff([0] + p.durations)
projection_dict = dict((conn.name, conn) for conn in topo.sim.connections())
outputs = outputs if len(outputs) > 0 else topo.sim.objects(Sheet).keys() + projection_dict.keys()
responses = defaultdict(dict)
for i, d in enumerate(durations):
topo.sim.run(d)
time = p.durations[i]
if hasattr(topo, 'guimain'):
update_activity(p.install_sheetview)
topo.guimain.refresh_activity_windows()
if p.return_responses:
for output in outputs:
if output in topo.sim.objects(Sheet).keys():
responses[(output, time)] = topo.sim[output].activity.copy()
elif output in projection_dict:
responses[(output, time)] = projection_dict[output].activity.copy()
if p.restore_events:
topo.sim.event_pop()
# turn sheets' plasticity and output_fn plasticity back on if we
# turned it off before
if not p.plastic:
for sheet in topo.sim.objects(Sheet).values():
sheet.restore_plasticity_state()
if not p.apply_output_fns:
for each in topo.sim.objects(Sheet).values():
each.apply_output_fns = True
if not p.overwrite_previous:
restore_input_generators()
if p.restore_state:
topo.sim.state_pop()
return responses
def version_int(v):
"""
Convert a version four-tuple to a format that can be used to compare
version numbers.
"""
return int("%02d%02d%02d%05d" % v)
__version__ = param.Version(release=(0,9,8), fpath=__file__,
commit="3a1c9e8a1", reponame='topographica')
commit = __version__.commit
version = tuple(list(__version__.release) +[__version__.commit_count])
release = int("%02d%02d%02d%05d" % version)
# Patch for versions of param prior to 10 May 2013
param.main=param.Parameterized(name="main")
# Determine which paths to search for input files
#
# By default, searches in:
# - the current working directory (the default value of param.resolve_path.search_paths),
# - the parent of topo (to get images/, examples/, etc.)
# - topo (for backwards compatibility, e.g. for finding color keys)
#
_package_path = os.path.split(__file__)[0] # location of topo
_root_path = os.path.abspath(os.path.join(_package_path,'..')) # parent of topo
param.resolve_path.search_paths+=[_root_path,_package_path]
def __call__(self, script_file, **params_to_override):
p = ParamOverrides(self, params_to_override, allow_extra_keywords=True)
import os
import shutil
# Construct simulation name, etc.
scriptbase = re.sub('.ty$', '', os.path.basename(script_file))
prefix = ""
if p.timestamp == (0, 0): prefix += time.strftime(p.name_time_format)
else: prefix += time.strftime(p.name_time_format, p.timestamp)
prefix += "_" + scriptbase + "_" + p.tag
simname = prefix
# Construct parameter-value portion of filename; should do more filtering
# CBENHANCEMENT: should provide chance for user to specify a
# function (i.e. make this a function, and have a parameter to
# allow the function to be overridden).
# And sort by name by default? Skip ones that aren't different
# from default, or at least put them at the end?
prefix += p.dirname_params_filter(p.extra_keywords())
# Set provided parameter values in main namespace
from topo.misc.commandline import global_params
global_params.set_in_context(**p.extra_keywords())
# Create output directories
if not os.path.isdir(normalize_path(p['output_directory'])):
try:
os.mkdir(normalize_path(p['output_directory']))
except OSError:
pass # Catches potential race condition (simultaneous run_batch runs)
dirname = self._truncate(p, p.dirname_prefix + prefix)
normalize_path.prefix = normalize_path(
os.path.join(p['output_directory'], dirname))
if os.path.isdir(normalize_path.prefix):
print "Batch run: Warning -- directory already exists!"
print "Run aborted; wait one minute before trying again, or else rename existing directory: \n" + \
normalize_path.prefix
sys.exit(-1)
else:
os.mkdir(normalize_path.prefix)
print "Batch run output will be in " + normalize_path.prefix
if p['vc_info']:
_print_vc_info(simname + ".diffs")
hostinfo = "Host: " + " ".join(platform.uname())
topographicalocation = "Topographica: " + os.path.abspath(sys.argv[0])
topolocation = "topo package: " + os.path.abspath(topo.__file__)
scriptlocation = "script: " + os.path.abspath(script_file)
starttime = time.time()
startnote = "Batch run started at %s." % time.strftime(
"%a %d %b %Y %H:%M:%S +0000", time.gmtime())
# store a re-runnable copy of the command used to start this batch run
try:
# pipes.quote is undocumented, so I'm not sure which
# versions of python include it (I checked python 2.6 and
# 2.7 on linux; they both have it).
import pipes
quotefn = pipes.quote
except (ImportError, AttributeError):
# command will need a human to insert quotes before it can be re-used
quotefn = lambda x: x
command_used_to_start = string.join([quotefn(arg) for arg in sys.argv])
# CBENHANCEMENT: would be nice to separately write out a
# runnable script that does everything necessary to
# re-generate results (applies diffs etc).
# Shadow stdout to a .out file in the output directory, so that
# print statements will go to both the file and to stdout.
batch_output = open(normalize_path(simname + ".out"), 'w')
batch_output.write(command_used_to_start + "\n")
sys.stdout = MultiFile(batch_output, sys.stdout)
print
print hostinfo
print topographicalocation
print topolocation
print scriptlocation
print
print startnote
from topo.misc.commandline import auto_import_commands
auto_import_commands()
# Ensure that saved state includes all parameter values
from topo.command import save_script_repr
param.parameterized.script_repr_suppress_defaults = False
# Save a copy of the script file for reference
shutil.copy2(script_file, normalize_path.prefix)
shutil.move(normalize_path(scriptbase + ".ty"),
normalize_path(simname + ".ty"))
# Default case: times is just a number that scales a standard list of times
times = p['times']
if not isinstance(times, list):
times = [
t * times for t in
[0, 50, 100, 500, 1000, 2000, 3000, 4000, 5000, 10000]
]
# Run script in main
error_count = 0
initial_warning_count = param.parameterized.warning_count
try:
execfile(script_file, __main__.__dict__) #global_params.context
global_params.check_for_unused_names()
if p.save_global_params:
_save_parameters(p.extra_keywords(),
simname + ".global_params.pickle")
print_sizes()
topo.sim.name = simname
# Run each segment, doing the analysis and saving the script state each time
for run_to in times:
topo.sim.run(run_to - topo.sim.time())
p['analysis_fn']()
save_script_repr()
elapsedtime = time.time() - starttime
param.Parameterized(name="run_batch").message(
"Elapsed real time %02d:%02d." %
(int(elapsedtime / 60), int(elapsedtime % 60)))
if p['snapshot']:
save_snapshot()
except:
error_count += 1
import traceback
traceback.print_exc(file=sys.stdout)
sys.stderr.write("Warning -- Error detected: execution halted.\n")
print "\nBatch run completed at %s." % time.strftime(
"%a %d %b %Y %H:%M:%S +0000", time.gmtime())
print "There were %d error(s) and %d warning(s)%s." % \
(error_count,(param.parameterized.warning_count-initial_warning_count),
((" (plus %d warning(s) prior to entering run_batch)"%initial_warning_count
if initial_warning_count>0 else "")))
# restore stdout
sys.stdout = sys.__stdout__
batch_output.close()
