Import VelocityClamp in hooke.plugin.flatfilt for ConvolutionPeakCommand._setup

Allow negative voltages in hooke.driver.picoforce.PicoForceDriver._translate_block_info

Fix self.hooke -> hooke typo in hooke.plugin.flatfilt.FlatFilterCommand.filter

Fix broken hooke.plugin.playlist.playlist_name_callback

Remove if __name__ == '__main__' section of hooke.hooke

Add unicode-capable IO to hooke.ui.commandline.

The previous implementation produced:
  $ python bin/hooke -c 'flat_filter_playlist'
  ...
  hooke> Traceback (most recent call last):
  ...
  UnicodeEncodeError: 'ascii' codec can't encode character u'\xec'...

The new encoding detection functions in hooke.util.encoding came from
my libbe.util.encoding module for Bugs Everywhere.  From my original
BE commit (Tue 2008-11-25 15:47:19 -0500):

  get_encoding() is from Trac
    http://trac.edgewall.org/browser/trunk/trac/util/datefmt.py
    format_datetime()
  Trac has a BSD license
    http://trac.edgewall.org/wiki/TracLicense
  I don't know if such a small snippet requires us to "reproduce the
  above copyright" or where we need to reproduce it if it is needed.

  The stdout/stdin replacement code follows
    http://wiki.python.org/moin/ShellRedirectionFails

  References:
    http://wiki.python.org/moin/Unicode
    http://www.amk.ca/python/howto/unicode
    http://www.python.org/dev/peps/pep-0100/

Remove two debugging prints from hooke.ui.commandline

Adjust update_copyright hacks to follow plugin.peakspot -> util.peak move

Major plugin restructuring.

The restructuring makes major improvements in:
  * numpy/scipy utilization (for speed)
  * functional encapsulation (breaking long, complicated functions
    into easily understood pieces, and sharing those pieces between
    related Commands).

Renames:
  * generalclamp -> fclamp
  * generalvclamp -> vclamp
  * generaltccd -> tccd
  * peakspot -> hooke.util.peak

Splits:
  * flatfilts -> flatfily
             `-> convfilt

The config files convfilt.conf and flatfilts.ini were also
internalized into their respective plugins' .default_settings().

Remove debugging print command from hooke.util.calculus.derivative

Fix a pickling problems with hooke.plugin.playlist.FilterCommand.

Pickle doesn't like functions that aren't defined the top level of
modules (such as NoteFilterCommand's old lambda filter_fn).  Add a
warning to that effect to the FilterCommand doc string, and rearrange
to encourage the use of methods (which are less likely to be defined
on the fly than functions).

Also:
  * Added pickle queue debugging code to hooke.hooke.  This isn't the
    first tiem I've had a pickling problem.  This code (when enabled),
    makes it easier for me to track down the failing code.
  * Fix a typo in hooke.hooke.HookeRunner.run (self.ui -> hooke.ui).
  * Remove a snip of trailing whitespace in hooke.hooke.

Allow extra arguments to NoteIndexList.filter's filter_fn

Move argument_to_setting before plugin loading code in hooke.plugin.

Otherwise Python loads the plugins before argument_to_setting has been
defined, which makes it hard for the plugins to use the function ;).

Add Numpy crossreferences to hooke.util.fft

Introduce intersphinx to Numpy, Scipy, and Matplotlib

Add hooke.plugin.argument_to_setting to convert Arguments -> Settings.

This will make it easy for Plugins to generate Settings matching
Command Arguments.

Actually, pass plugin instance to Command.__init__.

Rather than using Plugin._setup_commands, because the commands may
wish to use some aspects of the Plugin during initialization (e.g. to
build argument lists from plugin settings).  The previous
implemetation gave the commands no way to respond to the attached
plugin instance.

Rework Plugin.commands() to include _setup_commands().

The previous implementation gave Commands no way to access the
Plugin's configuration.

Fix syntax errors in hooke.plugin.curve

Finish translating the hooke.plugin.curve Commands from procplots.

Converted hooke.util.fft to Hooke coding style.

* Add numpydoc docstrings (to most functions)
* Converted hackish test suites to hackish `unittest.TestCase`s.
  Still ugly, but now `nosetests` finds them.
  They should really use .assertAlmostEqual and company...
* Added neccessary function definitions to doc/conf.py for the
  'math' sections of fft's docstrings.

Add intersphinx_mapping to doc/conf.py

This tell's intersphinx where to find documentation for other
projects.  Currently we've only told it about the standard Python
libraries.

http://sphinx.pocoo.org/latest/ext/intersphinx.html#confval-intersphinx_mapping

Add Sphinx extensions sphinx.ext.intersphinx sphinx.ext.pngmath.

* intersphinx allows documentation linking between known Sphinx packages.
  http://sphinx.pocoo.org/ext/intersphinx.html
* pngmath allows LaTeX inclusion via the math directive
  http://sphinx.pocoo.org/ext/math.html

Also reorder extension list following:
  sphinx.* alphabetically
  everything else aphabetically

Ran ./update_copyright.py to setup copyrights in caclulus and fft.

Also corrects a name typo in th picoforce copyright.  Sometimes I miss
keystrokes and Emacs starts running aspell without me noticing :p.

Adjusted hooke.util.calculus.derivative.__doc__ so Sphinx doesn't die.

Merged my unitary FFT wrappers (FFT_tools) as hooke.util.fft.

Origininally versioned in Git and licensed under BSD, but I wrote
them, so I'm relicensing under the LGPL for Hooke.

The original git repository was:
  http://www.physics.drexel.edu/~wking/code/git/FFT_tools.git/

Relicensed FFT_tools.py under Hooke's LGPL

Merged hooke.plugin.plotmanip into hooke.plugin.curve.

Also:
  * Fixed a number of typos in hooke.plugin.curve.
  * Rewrote derivative code for Numpy in
    hooke.util.calculus.derivative.
  * Removed FFT code (I'm replacing it with my FFT_tools module
    shortly).
  * Moved v-clamp-specific code into generalvclamp.
  * Moved plotmanips to hooke.plugin.plotmanip holding area.

Remove leftover curve.InfoCommand cruft from ExportCommand.__init__.

Moving hooke.plugin.procplots to .curve in preparation for merge

Started translating hooke.plugin.multifit to new Plugin/Command architecture.

Add REAMDE and playlist.hkp for Hemingway force clamp curves.

Added sample Hemingway force-clamp curves

Moved test/data/titin to more descriptive test/data/vclamp_picoforce

Add REAMDE and playlist.hkp for titin I-27 curves.

Added 100 sample velocity-clamp curves for titin I-27

Fix rief1997 footnote in hooke.experiment.VelocityClamp

Updated hooke.driver.picoforce to new Driver class.

This is a fairly major rewrite of the previous PicoForce driver.  I've
cleaned up header parsing and tried to break trace -> block conversion
up into compact functions.  The meaning of many PicoForce file
constants is still unclear to me though, so I may have gotten some
things wrong.

Also:
  * Added references for each hooke.experiment.Experiment subclass.
  * TutorialDriver sets curve.info['experiment'] to an Experiment subclass.
  * An adjusted test.curve_info now passes.

While we're translating the old experiment strings to the new
Experiment classes, the following conversion table may be useful:

  'clamp'  -> ForceClamp
  'smfs'   -> VelocityClamp
  'smfluo' -> TwoColorCoincidenceDetection

Fixed bugs in hooke.curve.Data.__new__ and added doctests

Add Curve loading to hooke.playlist.Playlist.

Highlights:
  * NotRecognized.__get/setstate__ for Pickling through the Queues.
    Perhaps this would be better solved in Failure.__get/setstate__?
    The current fix works for the moment though.
  * Use Curve.data == None to indicate unloaded curves.
  * Fix TutorialDriver.is_me(self) -> is_me(self, path)
  * Added ._load* to Playlist, so it only caches ._max_loaded curves
    in memory.
  * Fix broken Playlist.from_string doctest.

Moved doc/hooke.jpg to doc/img/hooke.jpg

Add hooke.plugin.curve (moved from hooke.plugin.curvetools)

Provides 'curve info' and 'export' commands.  Added test.curve_info
to test the 'curve info' command, but it currently fails due to
unimplemnted Curve loading.

Also:
 * Minor docstring cleanups in hooke.plugin.playlist
 * Moved some functions to hooke.plugin.generalvclamp.  I'm not clear
   on Experiment-specific Curve interpretation yet, but these
   functions (which will eventually be Commands) seem better placed
   here.
   * fit_interval_nm
   * find_current_peak
   * pickup_contact_point
   * baseline_points

Added .hooke.cfg to .hgignore.

The local config copy auto-generated by hooke.hooke.main().  We don't
want anyone adding this to the versioning system by accident.

Broke out Hooke.run and Hooke.run_lines into HookeRunner.

This allows the main process access to the command process' possibly
altered Hooke instance.  For example:
  >>> h = Hooke()
  >>> r = HookeRunner()
  >>> h = r.run_lines(h, ['load_playlist test/data/test'])
  >>> h = r.run_lines(h, ['curve_info --all=True'])
With the old implementation, second run_lines() call would fail
because the playlist was only loaded in the first command process'
Hooke instance, not the Hooke instance that the main (UI) process
held.

Pull Hooke.run*() multiprocessing setup/teardown into ._setup/_cleanup_run.

Limits code duplication between .run() and .run_lines().

Add hooke.playlist.NoteIndexList.__str__() method.

Now playlists etc. will flatten themselves to strings with:
  '...%s...' % instance.

Unset executible bits in curvetools.py and jumpstat.py permissions.

Ran update_copyright.py, updating all the copyright blurbs and adding AUTHORS.

Use ALIASES and AUTHOR_HACKS handling in update_copyright.update_authors.

The previously generated AUTHORS file was the raw list of VCS
commiters.

Updated copyright blurbs in all files to '# Copyright'

This tag will be replaced by update_copyright.py with the full
copyright blurb for each file.

Further author/year workarounds in update_copyright.py.

Add AUTHOR_HACKS and YEAR_HACKS to update_copyright.py

This works around holes in the versioning where files were initially
released before being added to the versioning system, or they were
never committed under the name of one of the authors.

Update canonical copyright names for 'illysam' and 'pancaldi.paulo'.

Also add the missing '.82' to Fabrizio's alias.

Fix some doctests in update_copyright.py.

And make some adjustments so that update_copyright.py can update its
own copyright blurb without changing anything else inside itself.

Rearrange license text and add update_copyright.py.

Following http://www.gnu.org/licenses/gpl-howto.html
  * Moved LGPLv3 text from LICENSE -> COPYING.LESSER
  * Brought in GPLv3 text -> COPYING

update_copyright.py automates the maitenance of boilerplate copyright
information at the head of every file.

Added integration test directory test/ and load_playlist test.

Run all integration tests with:
  nosetests --with-doctest --doctest-tests test/

Updated .hgignore to ignore documentation build files.

Added .hgignore masking *.pyc files

Added distutils-based setup.py.

Fix git->hg and wget -o -> -O in doc/install.txt snapshot command.

Path change because of Git->Mercurial migration.

wget
  -O --output-document    sets the document file.
  -o --output-file        sets the logfile.

Updated fork project info for Rolf and my branches in doc/install.txt.

I think I found where Rolf's code is (SVN illysam branch), and I
migrated my Git-versioned fork to Mercurial.

Add --script and --command to bin/hooke

Save playlist digest on loading.

The previous implementation felt that playlists were not saved
(.is_saved() -> False) when the playlists had not been altered since
loading.

We *don't* save the digest when we load from a string, because
that string is not necessarily on disk and we *do* want to save
it, even if the playlist hasn't change since loading.

I also removed the return bits, since FilePlaylist._from_xml_doc()
doesn't return anything.

Actually set self.name in hooke.playlist.FilePlaylist.set_path

Fix str() bug in hooke.ui.commandline.LocalExitCommand save msg.

Old implemtation crashed if Playlist.name was None.

Move hooke/test/default.000 -> test/data/picoforce.000

+ corresponding update to test/data/test.hkp.

Actually set self.path in hooke.playlist.FilePlaylist.set_path

Add all_drivers_callback to hooke.plugin.playlist.LoadCommand.

I can't imagine the user not wanting to use all available playlists.
They still can, but specifiying a sublist is now optional.

Fix typos in hooke.playlist.FilePlaylist.set_path

Fix bug in hooke.ui.commandline.DoCommand._check_argument_length() max_arg calculation.

Moved test and mfp_igor_scripts directories around

Split out "Troubleshooting" into doc/bugs.txt.

This section will probably grow ;).
+ other textual cleanups.

Fix doc/index.txt references to auto-generated pages

:ref:`~...` -> :ref:`...` following
  http://sphinx.pocoo.org/_sources/contents.txt

Documentation cleanups.

Specifically:
  * Escape *nix -> \*nix, because the bare * looks like an emphasis
    start mark.
  * Use :file:`...` to denote files.
  * Fix FHS reference '_ ..' -> '.. _'
  * Add a link to Sphinx's markup extensions.
  * Remove superfluous "Hooke" from section titles.
  * Use correct section linking:
      X.txt -> X
      :doc:`X`
    see
      http://sphinx.pocoo.org/concepts.html#document-names
      http://sphinx.pocoo.org/markup/inline.html#role-doc
  * Use two spaces (not one) at start of sentences.
  * `code` -> ``code`` (the way I had things originally :p).  See
      http://sphinx.pocoo.org/markup/inline.html#role-samp

Don't abbreviate multiprocessing.Queue in hacking.txt

Remove ~~ in info attribute reference of doc/hacking.txt

Fix hooke.utils -> hooke.util typo in doc/hacking.txt

Add :class: bit to many `...` escapes in hacking.txt and index.txt

Standardize example indentation to 4 spaces in doc/tutorial.txt

Sync doc/tutorial.txt splash text with hooke.ui.UserInterface._splash_text.

Also:
 * Flesh out doc/architecture.txt
 * Replace a number of '``' escapes with '`'.  My reStructuredText was
   rusty on the first pass through the documentation ;).

Nothing useful left in hooke_cli, removed.

More commands moved from hooke_cli to hooke.ui.gui.plotcommands stub

Moved config handling commands from hooke_cli to hooke.plugin.config.

Also:
  * Moved construct_graph and IsSubclass from hooke.plugin to
    hooke.util.pluggable to avoid import cycles and cleanup
    hooke.plugin.
  * Added hooke.interaction.ReloadUserInterfaceConfig to trigger UI
    reconfigure.
  * Added hooke.ui.UserInterface.reload_config (triggered by above).
  * Pass CommandLine instance to HookeCmd, so it can reconfigure
    the UI.

Moved printlist command from hooke_cli -> hooke.plugin.playlist.CurveListCommand.

Moved index command from hooke_cli -> hooke.plugin.playlist.IndexCommand.

Removed next/previous commands from hooke_cli

Superseded by hooke.plugin.playlist commands.

Moved plot commands from hooke_cli -> hooke.ui.gui.plotcommands stub.

Moved export command from hooke_cli -> hooke.ui.gui.export stub.

Moved txt command from hooke_cli -> hooke.plugin.curvetools stub.

Moved note handling commands to hooke.plugin.note.

Also:
  * Fixed graph dependency creation in hooke.plugin.construct_graph.
    The previous implemetation had Plugin instances as parents, not
    Node instances.
  * Moved a few builtin modules from hooke.plugin.PLUGIN_MODULES to
    .BUILTIN_MODULES.
  * Fixup unsaved playlist detection in
    hooke.ui.commandline.LocalExitCommand._run

notelog has been superseded by hooke.plugin.playlist.SaveCommand

The notes will be stored in Playlist.info['note'], and the info dict
is saved in the playlist file format.

Run hooke.command.Argument.callback every time (if defined).

The previous implemtation which only ran the callback if a value was
given was too confusing.

Also:
  * Added hooke.plugin.playlist.NoteFilterCommand.  In general, I
    think running commands this way is pretty awkward.  We should
    probably just use a Python interpreter instead of cmd.Cmd, but
    for now, NoteFilterCommand provides something like the old
    'copylog' functionality.
  * Removed a bunch of superseded code from hooke.hooke_cli.

Fix hooke.ui.commandline imports following hooke.interaction creation.

Moved hooke.libpeakspot -> hooke.plugin.peakspot

Moved hooke.formatter -> hooke.ui.gui.formatter.

The code seemed GUI-specific.

Moved Interaction related classes from hooke.command -> hooke.interaction.

Breaking them out makes hooke.command clearer for new readers.

Also moved remaining libhooke functionality ->
hooke.ui.gui.point_request, although it will need reworking (like the
rest of the stuff in hooke.ui.gui) once I finish the architecture
transition.

Removed hooke.liboutlet/.libviewer/.plugin.viewer.

Functionality superseded by hooke.ui.

Removed hooke.libinput

Functionality superseded by hooke.command.Request/.Response.

Use *_SETTING_SECTION in hooke.plugin/.driver/.ui for section name

Avoid constant duplication in code (brittle).

Removed hooke.hooke.TestHooke.

I couldn't find a flexible enough equality comparison between the two
Hooke instances.  It doesn't seem worth it to add .__eq__ or .__cmp__
methods to all of my classes just to test Queue-proof-ness.  Maybe I'm
just lazy...  Anyhow, the original problem case now works:

  $echo 'debug' | python bin/hooke
  This is Hooke, version 0.9.0.devel (Kenzo)

  COPYRIGHT
  ----
  hooke> <hooke.hooke.Hooke object at 0xb6a0bcac>
  Success
  ...