Skip to content
Snippets Groups Projects
Commit b6bc93e1 authored by Pete Peterson's avatar Pete Peterson Committed by GitHub
Browse files

Merge pull request #18557 from rosswhitfield/remove_lib1to2 

Remove Mantid API 1to2 migration stuff
parents 002b67d7 51457581
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 985 deletions
.flake8
+ 0
− 1
View file @ b6bc93e1
......@@ -15,7 +15,6 @@ exclude =
MantidPlot,
MantidQt,
QtPropertyBrowser,
scripts/lib1to2,
scripts/test,
Testing/PerformanceTests,
Testing/SystemTests/lib,
......
buildconfig/CMake/PylintSetup.cmake
+ 0
− 1
View file @ b6bc93e1
......@@ -32,7 +32,6 @@ if ( PYLINT_FOUND )
docs/sphinxext/mantiddoc
)
set ( PYLINT_EXCLUDES
scripts/lib1to2
scripts/test
Testing/SystemTests/tests/analysis/reference
)
......
docs/source/api/python/changes.rst deleted 100644 → 0
+ 0
− 131
View file @ 002b67d7
.. _pythonapi-changes:
=============================
Changes between 1.0 and 2.0
=============================
.. note::
This page is intended for those users who have used Python in Mantid v1.x. For
new users, see the `getting started guides <http://www.mantidproject.org/Main_Page>`_.
After feedback from the usage of Python within Mantid it was decided that
some changes to the API would be helpful to make general usage simpler. Unfortunately,
it was not possible to make these changes without breaking backwards compatability.
It was therefore decided that a new API would be introduced, running alongside
the existing API for now, to cope with these changes. This page describes the high-level
changes.
Overview
--------
The new-style API is now the default in MantidPlot so if all of your scripts run here then
you do not need to worry about importing the correct modules, it has already been done
for you. If you run from a stand-alone interpreter then the quickest way to get access to
the new API is
.. code-block:: python
from mantid.simpleapi import *
Changes
-------
* The *MantidFramework* module no longer exists, it has been replaced with the *mantid* package, i.e
* *import MantidFramework* -> *import mantid*
* The *mtd* object can now only be used to access workspaces from Mantid. In the v1 API there
were many additional functions attached to *mtd* such as *sendLogMessage*, *deleteWorkspace* and *settings*. These
are no longer available, there replacements are:
* *mtd.initialize()* has been removed and has no counterpart as it is unnecessary
* *mtd.sendLogMessage("msg")* -> *logger.information("msg")*
* *mtd.deleteWorkspace(ws)* -> *DeleteWorkspace(ws)*
* *mtd.settings* -> *config*
* *mtd.getSettings* -> *config*
* *mtd.workspaceExists("ws")* -> *mtd.doesExist("ws")*
* *mtd.settings.facility* -> *config.getFacility*
* *mtd.getConfigProperty* -> *config.getString*
* *mtd[]* will now raise an *KeyError* if a workspace does not exist rather than returning *None*.
* The *isGroup* function on a workspace no longer exists. To test for a group use the Python *isinstance* function::
ws = mtd["name"]
from mantid.api import WorkspaceGroup # (only required as while the old API still exists.)
if isinstance(ws, WorkspaceGroup):
print "is group"
else:
print "is not a group"
* The *getSampleDetails()* function has been removed. It should be replaced with *getRun()*.
* The Axis functions *createNumericAxis*, *createTextAxis*, *createSpectraAxis* have been removed. A spectra axis can no longer be created
from Python as it is the default workspace axis & changing it almost always results in unexpected behaviour. The functions have been
replaced, they new ones take the same arguments, with:
* *createNumericAxis* -> *NumericAxis.create*
* *createTextAxis* -> *TextAxis.create*
* The *.workspace()* function on algorithm functions has been removed & they now return their outputs (see here for more details), i.e.::
run = Load('SomeRunFile.ext')
print run.getNumberHistograms()
ei, mon_peak, mon_index, tzero = GetEi(run, 1,2, 12.0) # This will run GetEi and return the outputs as a tuple and the Python will unpack them for you
* The output workspace name is taken from the variable that it is assigned to::
run = Load('SomeRunFile.ext') # loads the file into a workspace called "run"
* It is still possible provide a different workspace name and use mtd::
run = Load(Filename='SomeRunFile.ext', OutputWorkspace="rawfile") # name in mantid will be "rawfile"
rawfile = mtd["rawfile"]
print run.getNumberHistograms()
print rawfile.getNumberHistograms()
* The *qti* module no longer exists. All user scripts should simply use the *mantidplot* module which contains
all of the *qti* functionality but adds protection against crashes from closed windows.
* There have also been changes with Python algorithm syntax.
Automatic Migration
-------------------
A script is included with the distribution that is able to translate simple scripts from the the old API to the new API. It covers the basics of the replacements mentioned
above along with converting some algorithm calls. It will create a backup of the original script with the string *.mantidbackup* appended to it. Currently the script
does not handle
* old algorithm calls that use a return value, e.g. alg = Load('SomeRunFile.ext','runWS')
* Python algorithms.
Any script containing the above will raise an error in the migration process and restore the original script from the backup.
An old API algorithm call that does **NOT** use a return value, such as
.. code-block:: python
Load('SomeRunFile.ext','runWS')
which will be translated to
.. code-block:: python
runWS = Load(Filename='SomeRunFile.ext')
along with any of the text replacements mentioned in the previous section
In order to run the script you will need to use the command line. On Windows: click start, run and type cmd; on OS X and Linux: open a terminal window. To run the script type::
python [MANTIDINSTALL]/scripts/migrate1to2.py file
where [MANTIDINSTALL] should be replaced by the location of the mantid install:
* Windows: C:/MantidInstall (only the default, please put the actual location)
* Mac OS X: /Applications/MantidPlot.app
* Linux: /opt/Mantid
and *file* should be replaced by the path to a single script file.
docs/source/api/python/index.rst
+ 0
− 2
View file @ b6bc93e1
......@@ -16,8 +16,6 @@ Reference
mantid <mantid/index>
mantidplot <mantidplot/index>
Changes between version 1.0 and 2.0 of the API are described :ref:`here <pythonapi-changes>`.
.. toctree::
:hidden:
......
scripts/CMakeLists.txt
+ 0
− 3
View file @ b6bc93e1
......@@ -3,7 +3,6 @@
add_subdirectory(FilterEvents)
add_subdirectory(HFIRPowderReduction)
add_subdirectory(Interface/ui)
add_subdirectory(lib1to2/gui)
add_subdirectory(TofConverter)
add_subdirectory(HFIR_4Circle_Reduction)
......@@ -13,7 +12,6 @@ add_custom_target(CompilePyUI DEPENDS
CompileUIHFIRPowderReduction
CompileUITofConverter
CompileUIUI
CompileUILib1To2
CompileUIHFIR_4Circle_Reduction
)
......@@ -23,7 +21,6 @@ set_property ( TARGET CompileUIFilterEvents PROPERTY FOLDER "CompilePyUI" )
set_property ( TARGET CompileUIHFIRPowderReduction PROPERTY FOLDER "CompilePyUI" )
set_property ( TARGET CompileUITofConverter PROPERTY FOLDER "CompilePyUI" )
set_property ( TARGET CompileUIUI PROPERTY FOLDER "CompilePyUI" )
set_property ( TARGET CompileUILib1To2 PROPERTY FOLDER "CompilePyUI" )
set_property ( TARGET CompileUIHFIR_4Circle_Reduction PROPERTY FOLDER "CompilePyUI" )
set ( TEST_PY_FILES
......
scripts/lib1to2/__init__.py deleted 100644 → 0
+ 0
− 1
View file @ 002b67d7
# Intentionally empty
\ No newline at end of file
scripts/lib1to2/astbuilder.py deleted 100644 → 0
+ 0
− 115
View file @ 002b67d7
"""
Module containing functions for parsing and modification of an AST.
Taken from http://pythoscope.org/ and modified
"""
from lib2to3 import pygram, pytree
from lib2to3.pgen2 import driver, token
from lib2to3.pgen2.parse import ParseError
from lib2to3.pygram import python_symbols as syms
from lib2to3.pytree import Node, Leaf
__all__ = ["EmptyCode", "Newline", "ParseError", "clone", "create_import",
"insert_after", "insert_before", "parse", "parse_fragment", "regenerate"]
EmptyCode = lambda: Node(syms.file_input, [])
Newline = lambda: Leaf(token.NEWLINE, "\n")
def quoted_block(text):
return ''.join(["> %s" % line for line in text.splitlines(True)])
def clone(tree):
"""Clone the tree, preserving its add_newline attribute.
"""
if tree is None:
return None
new_tree = tree.clone()
if hasattr(tree, 'added_newline') and tree.added_newline:
new_tree.added_newline = True
return new_tree
def create_import(import_desc):
"""Create an AST representing import statement from given description.
>>> regenerate(create_import("unittest"))
'import unittest\\n'
>>> regenerate(create_import(("nose", "SkipTest")))
'from nose import SkipTest\\n'
"""
if isinstance(import_desc, tuple):
package, name = import_desc
return Node(syms.import_from,
[Leaf(token.NAME, 'from'),
Leaf(token.NAME, package, prefix=" "),
Leaf(token.NAME, 'import', prefix=" "),
Leaf(token.NAME, name, prefix=" "),
Newline()])
else:
return Node(syms.import_name,
[Leaf(token.NAME, 'import'),
Leaf(token.NAME, import_desc, prefix=" "),
Newline()])
def index(node):
"""Return index this node is at in parent's children list.
"""
return node.parent.children.index(node)
def insert_after(node, code):
if not node.parent:
raise TypeError("Can't insert after node that doesn't have a parent.")
node.parent.insert_child(index(node)+1, code)
def insert_before(node, code):
if not node.parent:
raise TypeError("Can't insert before node that doesn't have a parent.")
node.parent.insert_child(index(node), code)
def parse(code):
"""String -> AST
Parse the string and return its AST representation. May raise
a ParseError exception.
"""
added_newline = False
if not code.endswith("\n"):
code += "\n"
added_newline = True
try:
drv = driver.Driver(pygram.python_grammar, pytree.convert)
result = drv.parse_string(code, True)
except ParseError:
print "Had problems parsing:\n%s\n" % quoted_block(code)
raise
# Always return a Node, not a Leaf.
if isinstance(result, Leaf):
result = Node(syms.file_input, [result])
result.added_newline = added_newline
return result
def parse_fragment(code):
"""Works like parse() but returns an object stripped of the file_input
wrapper. This eases merging this piece of code into other ones.
"""
parsed_code = parse(code)
if is_node_of_type(parsed_code, 'file_input') and \
len(parsed_code.children) == 2 and \
is_leaf_of_type(parsed_code.children[-1], token.ENDMARKER):
return parsed_code.children[0]
return parsed_code
def regenerate(tree):
"""AST -> String
Regenerate the source code from the AST tree.
"""
if hasattr(tree, 'added_newline') and tree.added_newline:
return str(tree)[:-1]
else:
return str(tree)
scripts/lib1to2/astvisitor.py deleted 100644 → 0
+ 0
− 215
View file @ 002b67d7
"""
Module containing ASTVistor class and helpers useful for traversing
and extracting information from an AST.
Taken from http://pythoscope.org/ and modified
"""
from lib2to3 import pytree
from lib2to3.patcomp import compile_pattern
from lib2to3.pgen2 import token
from lib2to3.pytree import Node, Leaf
__all__ = ["ASTError", "ASTVisitor", "descend", "find_last_leaf",
"get_starting_whitespace", "is_leaf_of_type", "is_node_of_type",
"remove_trailing_whitespace"]
def descend(tree, visitor_type):
"""Walk over the AST using a visitor of a given type and return the visitor
object once done.
"""
visitor = visitor_type()
visitor.visit(tree)
return visitor
def find_last_leaf(node):
if isinstance(node, Leaf):
return node
else:
return find_last_leaf(node.children[-1])
def get_starting_whitespace(code):
whitespace = ""
for child in code.children:
if is_leaf_of_type(child, token.NEWLINE, token.INDENT):
whitespace += child.value
else:
break
return whitespace
def remove_trailing_whitespace(code):
leaf = find_last_leaf(code)
leaf.prefix = leaf.prefix.replace(' ', '').replace('\t', '')
class ASTError(Exception):
pass
def is_leaf_of_type(leaf, *types):
return isinstance(leaf, Leaf) and leaf.type in types
def is_node_of_type(node, *types):
return isinstance(node, Node) and pytree.type_repr(node.type) in types
def leaf_value(leaf):
return leaf.value
def remove_commas(nodes):
def isnt_comma(node):
return not is_leaf_of_type(node, token.COMMA)
return filter(isnt_comma, nodes)
def remove_defaults(nodes):
ignore_next = False
for node in nodes:
if ignore_next is True:
ignore_next = False
continue
if is_leaf_of_type(node, token.EQUAL):
ignore_next = True
continue
yield node
def derive_class_name(node):
return str(node).strip()
def derive_class_names(node):
if node is None:
return []
elif is_node_of_type(node, 'arglist'):
return map(derive_class_name, remove_commas(node.children))
else:
return [derive_class_name(node)]
def derive_argument(node):
if is_leaf_of_type(node, token.NAME):
return node.value
elif is_node_of_type(node, 'tfpdef'):
return tuple(map(derive_argument,
remove_commas(node.children[1].children)))
def derive_arguments_from_typedargslist(typedargslist):
prefix = ''
for node in remove_defaults(remove_commas(typedargslist.children)):
if is_leaf_of_type(node, token.STAR):
prefix = '*'
elif is_leaf_of_type(node, token.DOUBLESTAR):
prefix = '**'
elif prefix:
yield prefix + derive_argument(node)
prefix = ''
else:
yield derive_argument(node)
def derive_arguments(node):
if node == []:
return []
elif is_node_of_type(node, 'typedargslist'):
return list(derive_arguments_from_typedargslist(node))
else:
return [derive_argument(node)]
def derive_import_name(node):
if is_leaf_of_type(node, token.NAME):
return node.value
elif is_node_of_type(node, 'dotted_as_name'):
return (derive_import_name(node.children[0]),
derive_import_name(node.children[2]))
elif is_node_of_type(node, 'dotted_name'):
return "".join(map(leaf_value, node.children))
def derive_import_names(node):
if node is None:
return None
elif is_node_of_type(node, 'dotted_as_names', 'import_as_names'):
return map(derive_import_name,
remove_commas(node.children))
else:
return [derive_import_name(node)]
class ASTVisitor(object):
DEFAULT_PATTERNS = [
('_visit_all', "file_input< nodes=any* >"),
('_visit_all', "suite< nodes=any* >"),
('_visit_class', "body=classdef< 'class' name=NAME ['(' bases=any ')'] ':' any >"),
('_visit_function', "body=funcdef< 'def' name=NAME parameters< '(' [args=any] ')' > ':' any >"),
('_visit_import', "body=import_name< 'import' names=any > | body=import_from< 'from' import_from=any 'import' names=any >"),
('_visit_lambda_assign', "expr_stmt< name=NAME '=' lambdef< 'lambda' [args=any] ':' any > >"),
('_visit_main_snippet', "body=if_stmt< 'if' comparison< '__name__' '==' (\"'__main__'\" | '\"__main__\"' ) > ':' any >"),
]
def __init__(self):
self.patterns = []
for method, pattern in self.DEFAULT_PATTERNS:
self.register_pattern(method, pattern)
def register_pattern(self, method, pattern):
"""Register method to handle given pattern.
"""
self.patterns.append((method, compile_pattern(pattern)))
def visit(self, tree):
"""Main entry point of the ASTVisitor class.
"""
if isinstance(tree, Leaf):
self.visit_leaf(tree)
elif isinstance(tree, Node):
self.visit_node(tree)
elif isinstance(tree, list):
for subtree in tree:
self.visit(subtree)
else:
raise ASTError("Unknown tree type: %r." % tree)
def visit_leaf(self, leaf):
pass
def visit_node(self, node):
for method, pattern in self.patterns:
results = {}
if pattern.match(node, results):
getattr(self, method)(results)
break
else:
# For unknown nodes simply descend to their list of children.
self.visit(node.children)
def visit_class(self, name, bases, body):
self.visit(body.children)
def visit_function(self, name, args, body):
self.visit(body.children)
def visit_import(self, names, import_from, body):
pass
def visit_lambda_assign(self, name, args):
pass
def visit_main_snippet(self, body):
pass
def _visit_all(self, results):
self.visit(results['nodes'])
def _visit_class(self, results):
self.visit_class(name=results['name'].value,
bases=derive_class_names(results.get('bases')),
body=results['body'])
def _visit_function(self, results):
self.visit_function(name=results['name'].value,
args=derive_arguments(results.get('args', [])),
body=results['body'])
def _visit_import(self, results):
self.visit_import(names=derive_import_names(results['names']),
import_from=derive_import_name(results.get('import_from')),
body=results['body'])
def _visit_lambda_assign(self, results):
self.visit_lambda_assign(name=results['name'].value,
args=derive_arguments(results.get('args', [])))
def _visit_main_snippet(self, results):
self.visit_main_snippet(body=results['body'])
scripts/lib1to2/grammar.py deleted 100644 → 0
+ 0
− 40
View file @ 002b67d7
"""
Defines the grammar translation from version 1 to version 2 of Mantid's Python API.
"""
import messages
import rules
import astbuilder
class Grammar(object):
"""
Translation from v1->v2 of the Python API
"""
def __init__(self):
pass
def translate(self, orig_code):
"""
Translates the input string, assuming it contains code written in
version 1 of Mantid's Python API, to version 2 of the PythonAPI
@param orig_code The original code string
@returns The translated string
"""
errors = []
# Simple string replacements
string_replace = rules.SimpleStringReplace()
translated = string_replace.apply(orig_code)
api_call_replace = rules.SimpleAPIFunctionCallReplace()
# Convert to an abstract syntax tree
# (uses the lib2to3 libraries that can convert AST back to source code)
tree = astbuilder.parse(translated)
tree = api_call_replace.apply_to_ast(tree)
errors.extend(api_call_replace.errors)
# No python algorithm support yet
if "PythonAlgorithm" in orig_code:
errors.append("Cannot fully migrate PythonAlgorithm.")
return astbuilder.regenerate(tree), errors
scripts/lib1to2/gui/CMakeLists.txt deleted 100644 → 0
+ 0
− 10
View file @ 002b67d7
include(UiToPy)
# List of UIs to Auto convert
set( UI_FILES
mainwindow.ui
)
UiToPy( UI_FILES CompileUILib1To2)
scripts/lib1to2/gui/__init__.py deleted 100644 → 0
+ 0
− 5
View file @ 002b67d7
"""
Defines the simple GUI for the migration process
"""
from main import start
\ No newline at end of file
scripts/lib1to2/gui/main.py deleted 100644 → 0
+ 0
− 28
View file @ 002b67d7
"""
Defines the entry point for the GUI app
"""
import lib1to2.messages as messages
from PyQt4.QtGui import QApplication
from mainwindow import MainWindow
def _qtapp():
"""Returns a QApplication object
If one does not already then one is created
"""
qapp = QApplication.instance()
if qapp is None:
qapp = QApplication([])
return qapp
def start(options, args):
"""Starts the GUI and passes the command line
arguments along to the GUI
@param options A dictionary of the options passed to the migration
@param args The positional command line arguments
load into the GUI
"""
messages.notify("Starting GUI")
app = _qtapp()
window = MainWindow()
window.show()
return app.exec_()
\ No newline at end of file
scripts/lib1to2/gui/mainwindow.py deleted 100644 → 0
+ 0
− 36
View file @ 002b67d7
"""
The main window for the GUI
"""
from PyQt4.QtCore import SIGNAL, SLOT, pyqtSlot
from PyQt4.QtGui import *
from ui_mainwindow import Ui_MainWindow
class MainWindow(QMainWindow, Ui_MainWindow):
"""The main window for the application
"""
def __init__(self, parent = None):
"""
Constructs and lays out the main window
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.connect(self.closeAction, SIGNAL("triggered()"),
qApp, SLOT("quit()"))
@pyqtSlot()
def chooseFiles():
"""Opens a file browser to allow a user
to select files for migration.
Emits the filesSelected() signal if any files
are selected
"""
pass
@pyqtSlot()
def addToTable(files):
"""
Adds files to the table, setting the
status to
"""
\ No newline at end of file
scripts/lib1to2/gui/mainwindow.ui deleted 100644 → 0
+ 0
− 133
View file @ 002b67d7
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>278</height>
</rect>
</property>
<property name="windowTitle">
<string>Python Script Migration</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QScrollArea" name="scrollArea">
<property name="widgetResizable">
<bool>true</bool>
</property>
<widget class="QWidget" name="scrollAreaWidgetContents">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>410</width>
<height>217</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QTableWidget" name="tableWidget">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>300</width>
<height>150</height>
</size>
</property>
<attribute name="horizontalHeaderCascadingSectionResizes">
<bool>false</bool>
</attribute>
<attribute name="horizontalHeaderStretchLastSection">
<bool>false</bool>
</attribute>
<column>
<property name="text">
<string>Script File</string>
</property>
</column>
<column>
<property name="text">
<string>Status</string>
</property>
</column>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="addFileAction">
<property name="text">
<string>Add File(s)</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="migrateAction">
<property name="text">
<string>Migrate</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<widget class="QStatusBar" name="statusbar"/>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>21</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
<property name="title">
<string>File</string>
</property>
<addaction name="separator"/>
<addaction name="separator"/>
<addaction name="closeAction"/>
</widget>
<addaction name="menuFile"/>
</widget>
<action name="closeAction">
<property name="text">
<string>Close</string>
</property>
<property name="toolTip">
<string>Close the application</string>
</property>
</action>
</widget>
<resources/>
<connections/>
</ui>
scripts/lib1to2/main.py deleted 100644 → 0
+ 0
− 51
View file @ 002b67d7
"""
Entry point for the 1->2 migration script
"""
import messages
import migrate
import gui
import optparse
def main(args):
"""
Starts the migration process
@param argv The arguments passed to the script
"""
parser = optparse.OptionParser(usage="migrate1to2 [options] file|dir")
parser.add_option("-n", "--nobackups", action="store_true", default=False,
help="Don't write backups for modified files. WARNING: This operation cannot be undone, use with care")
parser.add_option("-g", "--gui", action="store_true", default=False,
help="Starts the GUI")
options, args = parser.parse_args(args)
backup = not options.nobackups
files = get_files(args[0])
if options.gui:
retcode = gui.start(args, options)
else:
retcode = migrate.run(files, backup)
# Any clean up code
return retcode
def get_files(path):
"""
Returns the list of files to work on
@param path :: A string interpreted as a file or directory
"""
import os
if not type(path) == str:
raise ValueError("Expected string argument specfying file or path. Found %s" % type(path))
py_files = []
if os.path.isfile(path):
py_files.append(path)
else:
for root, dirs, files in os.walk(path):
for filename in files:
if filename.endswith(".py"):
py_files.append(os.path.join(root,filename))
return py_files
scripts/lib1to2/messages.py deleted 100644 → 0
+ 0
− 17
View file @ 002b67d7
"""
Defines functions for displaying messages to the user
"""
__QUIET__ = False
def quiet():
"""
"""
return __QUIET__
def notify(msg):
"""
Prints a message to the console
"""
if not quiet():
print msg
\ No newline at end of file
scripts/lib1to2/migrate.py deleted 100644 → 0
+ 0
− 152
View file @ 002b67d7
"""
Performs the actual migration
"""
import messages
from grammar import Grammar
import os
import shutil
import traceback
def run(files, backup=True):
"""
Runs the migration process
@param files A list of files to migrate
@param backup If true, the files are backed up before running the migration. The
backup file is the filename plus '.mantidbackup'
"""
if len(files) == 0:
messages.notify("Nothing to do!")
return 0
if type(files) == str:
files = [files]
reports = []
for filename in files:
script = ScriptFile(filename, backup)
try:
msg = script.migrate()
except Exception, exc:
traceback.print_exc()
script.restore_backup()
msg = "%s: Backup restored." % (filename)
reports.append(msg)
del script
messages.notify("\n" + "="*10 + " Report " + "="*10 + "\n")
for report in reports:
messages.notify(str(report))
return 0
class ScriptFile(object):
"""
Encapsulates a script file. The migration
process can be run by calling migrate
"""
_filename = None
dobackup = True
backup_ext = '.mantidbackup'
backup_filename = None
grammar = None
def getfilename(self):
return self._filename
def setfilename(self, filename):
"""Set the filename along with the backup filename
@param filename The full filename of the input
"""
if os.path.exists(filename):
self._filename = filename
self.backup_filename = filename + self.backup_ext
else:
raise ValueError("Invalid path '%s' passed to ScriptFile" % (filename))
filename = property(getfilename, setfilename)
def __init__(self, filename, backup = True):
self.setfilename(filename)
self.dobackup = backup
self.grammar = Grammar()
def migrate(self):
"""
Migrate the script to the new API
"""
self.backup()
input_file = open(self.filename, 'r')
input_as_str = input_file.read()
input_file.close()
converted_str, errors = self.grammar.translate(input_as_str)
filename = self.filename
if len(errors) > 0:
filename = self.filename + ".partial"
errors.append("Partial translation stored in '%s'" % filename)
output_file = open(filename, 'w')
output_file.write(converted_str)
output_file.close()
if len(errors) > 0:
raise RuntimeError("\n".join(errors))
outcome = MigrationStatus(MigrationStatus.Migrated)
return Report(self.filename, outcome)
def backup(self):
"""
Backup the file by copying it to
a different filename with the
extension defined by self.backup_ext
"""
if self.dobackup and self.filename is not None:
messages.notify("Backing up %s to %s" % (self.filename, self.backup_filename))
shutil.copy(self.filename, self.backup_filename)
def restore_backup(self):
"""
Copies the file from the backup to the original
location
"""
if not self.dobackup:
messages.notify("Cannot restore from backup, no backup was requested")
if os.path.exists(self.backup_filename):
shutil.copy(self.backup_filename, self.filename)
class Report(object):
"""Reports the outcome of a single migration"""
_filename = None
_status = None
def __init__(self, filename, status):
self._filename = filename
self._status = status
def __str__(self):
"""Returns a string representation of the report"""
return "%s: %s" % (self._filename, str(self._status))
class MigrationStatus(object):
Unconverted = 0
Migrated = 1
Errors = 2
def __init__(self, status):
self.status = status
def __str__(self):
"""Returns the status as a string"""
if self.status == self.Unconverted:
return "Unconverted"
elif self.status == self.Migrated:
return "Successfully migrated"
else:
return "Errors occurred"
scripts/lib1to2/rules/__init__.py deleted 100644 → 0
+ 0
− 5
View file @ 002b67d7
"""Defines various classes for applying translation rules
"""
from stringreplace import *
from simpleapireplace import *
from pythonalgorithmreplace import *
\ No newline at end of file
scripts/lib1to2/rules/pythonalgorithmreplace.py deleted 100644 → 0
+ 0
− 20
View file @ 002b67d7
"""Defines the rules for translation of Python algorithms
from v1 to v2
"""
import rules
class PythonAlgorithmReplace(rules.Rules):
def __init__(self):
rules.Rules.__init__(self)
def apply(self, text):
"""
Returns a replacement string for the input text
where the python algorithm calls have been replaced
@param text An input string to match
@returns A string containing the replacement or the original text
if no replacement was needed
"""
return text
scripts/lib1to2/rules/rules.py deleted 100644 → 0
+ 0
− 19
View file @ 002b67d7
"""Defines the rules base class and helper functions
"""
class Rules(object):
errors = []
def apply_to_ast(self, tree):
"""
Apply the transformation to the AST
"""
raise NotImplementedError("Derived classes should implement apply_to_ast()")
def apply(self, text):
"""
Interface for applying the rules
"""
raise NotImplementedError("Derived classes should implement apply()")
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment