adding python modules

Author: crazyeng

.gitignore

@@ -1,3 +1,3 @@
 __pycache__
 *.pyc
-*.class
+*$py.class

run.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+if __name__ == '__main__':
+
+    #this will perform an auto install of missing modules using PIP
+    #this won't be used in production, but it's handy when we are ginving this paclet to other developers
+
+    from wolframclient.cli.dispatch import execute_from_command_line
+
+    execute_from_command_line()

wolframclient/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

wolframclient/cli/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

wolframclient/cli/commands/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

wolframclient/cli/commands/benchmark.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from wolframclient.cli.utils import SimpleCommand
+from wolframclient.language.expression import wl
+from wolframclient.serializers import export
+from wolframclient.utils.debug import timed
+from wolframclient.utils.decorators import to_tuple
+from wolframclient.utils.encoding import force_text
+from wolframclient.utils.functional import first
+
+import os
+import tempfile
+
+class Command(SimpleCommand):
+
+    col_size    =  8
+    repetitions = 10
+    complexity  = [1, 2, 5, 10, 100, 1000]
+
+    @to_tuple
+    def complexity_handler(self, complexity):
+        for i in range(complexity):
+            yield [wl.Symbol, {"a": [1, 2, 3], 2:2}]
+
+    @timed
+    def export(self, *args, **opts):
+        return export(*args, **opts)
+
+    def formatted_time(self, *args, **opts):
+
+        time = sum(
+            first(self.export(*args, **opts))
+            for i in range(self.repetitions)
+        )
+
+        return '%.5f' % (time / self.repetitions)
+
+    def table_line(self, *iterable):
+        self.print(*(force_text(c).ljust(self.col_size) for c in iterable))
+
+    def table_divider(self, length):
+        self.print(*("-" * self.col_size for i in range(length)))
+
+    def handle(self, *args):
+
+        path = tempfile.gettempdir()
+
+        benchmarks = [
+            (c, self.complexity_handler(c))
+            for c in self.complexity
+        ]
+
+        self.print('dumping results in', path)
+
+        self.table_line("", *(force_text(c).ljust(self.col_size) for c in self.complexity))
+        self.table_divider(len(self.complexity) + 1)
+
+        for export_format, opts in (
+            ("wl",  dict()),
+            ("wxf", dict()),
+            ("wxf", dict(compress = True)),
+            ):
+            self.table_line(export_format, *(
+                self.formatted_time(
+                    expr,
+                    stream = os.path.join(path, 'benchmark-test-%s.%s' % (force_text(complexity).zfill(7), export_format)),
+                    format = export_format,
+                    **opts
+                )
+                for complexity, expr in benchmarks
+            ))
+
+        self.table_line()

wolframclient/cli/commands/test.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from wolframclient.cli.utils import discover_with_convention, SimpleCommand
+from wolframclient.utils import six
+from wolframclient.utils.importutils import import_string
+from wolframclient.utils.require import require_module
+
+import sys
+import unittest
+
+class Command(SimpleCommand):
+
+    modules = ['wolframclient.tests']
+    class_name = 'TestCase'
+
+    if six.JYTHON:
+        dependencies = (
+            ("pytz",  None),
+        )
+    else:
+        dependencies = (
+            ("pytz",  None),
+            ("numpy", None),
+        )
+
+    @property
+    def available_test_cases(self):
+        try:
+            return self._test_cases
+        except AttributeError:
+            self._test_cases = discover_with_convention(self.modules, self.class_name)
+            return self._test_cases
+
+    def add_arguments(self, parser):
+        parser.add_argument('args', nargs='*')
+
+    def import_test_case(self, name):
+
+        if not name in self.available_test_cases:
+
+            #we need to validate names manually, I was not able to use .add_argument(choices = ...)
+
+            self.print('Available test suites:')
+            for t in sorted(self.available_test_cases.keys()):
+                self.print(' -', t)
+
+            self.print()
+            self.print('%s is not a defined test suite. Create a TestCase in %s' % (
+                name,
+                " or ".join('%s.%s.%s' % (m, name, self.class_name) for m in self.modules)
+            ))
+
+            sys.exit(1)
+
+        return import_string(self.available_test_cases[name])
+
+    def handle(self, *args):
+
+        require_module(*self.dependencies)
+
+        suite = unittest.TestSuite()
+
+        for arg in (args or self.available_test_cases.keys()):
+            test_case = self.import_test_case(arg)
+
+            for func in test_case.discover_tests():
+                suite.addTest(test_case(func))
+
+        runner = unittest.TextTestRunner()
+        result = runner.run(suite)
+        if not result.wasSuccessful():
+            sys.exit(1)

wolframclient/cli/dispatch.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from wolframclient.cli.utils import discover_with_convention, SimpleCommand
+from wolframclient.utils.importutils import import_string
+
+import sys
+
+class DispatchCommand(SimpleCommand):
+
+    modules = ['wolframclient.cli.commands']
+    class_name = 'Command'
+
+    def subcommands(self):
+        return discover_with_convention(self.modules, self.class_name)
+
+    def handle(self, attr = None):
+        all_commands = self.subcommands()
+
+        if attr in all_commands:
+            return import_string(all_commands[attr])(self.subcommand_args(), name = all_commands[attr]).main()
+
+        self.print('Select one of the following commands:')
+        for command in sorted(all_commands.keys()):
+            self.print(' -', command)
+
+        sys.exit(1)
+
+    def subcommand_args(self):
+        argv = list(self.argv)
+        if len(argv) > 1:
+            argv.pop(1)
+        return argv
+
+    def main(self):
+        if len(self.argv) > 1 and self.argv[1]:
+            return self.handle(self.argv[1])
+        return self.handle()
+
+def execute_from_command_line(argv = None, **opts):
+    return DispatchCommand(argv).main()

wolframclient/cli/utils.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from wolframclient.utils.decorators import to_dict
+from wolframclient.utils.importutils import module_path
+
+import argparse
+import os
+import sys
+
+@to_dict
+def discover_with_convention(modules, import_name):
+    for module in modules:
+        for filename in os.listdir(module_path(module)):
+            basename, ext = os.path.splitext(filename)
+            if ext == '.py' and not basename == '__init__':
+                yield basename, '%s.%s.%s' % (module, basename, import_name)
+
+class SimpleCommand(object):
+
+    help  = None
+    print = print
+
+    def __init__(self, argv = None, name = None):
+        if argv is None:
+            self.argv = tuple(sys.argv)
+        else:
+            self.argv = argv
+
+        self.name = name
+
+    def create_parser(self):
+        return argparse.ArgumentParser(prog = self.name, description=self.help)
+
+    def add_arguments(self, parser):
+        pass
+
+    def handle(self, *args, **opts):
+        pass
+
+    def main(self):
+        parser = self.create_parser()
+        if parser:
+            self.add_arguments(parser)
+
+            cmd_options = vars(parser.parse_args(self.argv[1:]))
+            args = cmd_options.pop('args', ())
+            return self.handle(*args, **cmd_options)
+
+        return self.handle()

wolframclient/language/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

wolframclient/language/decorators.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from functools import wraps
+
+from wolframclient.language.exceptions import WolframLanguageExceptionBase, WolframLanguageExceptionFromPython
+from wolframclient.serializers import export
+
+import sys
+
+def safe_wl_execute(function, args = (), opts = {}, export_opts = {}):
+    try:
+        return export(function(*args, **opts), **export_opts)
+    except WolframLanguageExceptionBase as e:
+        e.set_traceback(*sys.exc_info())
+        return export(e, **export_opts)
+    except Exception as e:
+        return export(WolframLanguageExceptionFromPython(e, exec_info = sys.exc_info()), **export_opts)
+
+def to_wl(**export_opts):
+    def outer(function):
+        @wraps(function)
+        def inner(*args, **opts):
+            return safe_wl_execute(
+                function = function,
+                args = args,
+                opts = opts,
+                export_opts = export_opts,
+            )
+        return inner
+    return outer

wolframclient/language/exceptions.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from wolframclient.language.expression import wl
+from wolframclient.serializers.serializable import WLSerializable
+from wolframclient.utils.decorators import to_dict
+from wolframclient.utils.encoding import safe_force_text
+
+class WolframLanguageExceptionBase(WLSerializable):
+
+    def __init__(self):
+        raise NotImplementedError
+
+    def failure_tag(self):
+        raise NotImplementedError
+
+    def failure_template(self):
+        raise NotImplementedError
+
+    def failure_parameters(self):
+        return {}
+
+    def set_traceback(self, exc_type, exc_value, tb):
+        self.exc_type, self.exc_value, self.tb = exc_type, exc_value, tb
+
+    def to_wl(self, **opts):
+        return wl.Failure(
+            self.failure_tag(),
+            wl.Association(*(
+                wl.RuleDelayed(key, value)
+                for key, value in self.failure_meta().items()
+            ))
+        )
+
+    def add_traceback(self):
+        return True
+
+    @to_dict
+    def failure_meta(self):
+
+        template, parameters = self.failure_template(), self.failure_parameters()
+
+        if template:
+            yield "MessageTemplate",   template
+
+        if parameters:
+            yield "MessageParameters", parameters
+
+        if self.add_traceback() and self.tb:
+
+            from wolframclient.language.traceback import serialize_traceback
+
+            yield "Traceback", serialize_traceback(self.exc_type, self.exc_value, self.tb)
+
+class WolframLanguageExceptionFromPython(WolframLanguageExceptionBase):
+
+    def __init__(self, exception, exec_info = None):
+        self.original_exception = exception
+
+        if exec_info:
+            self.set_traceback(*exec_info)
+        else:
+            self.set_traceback(None, None, None)
+
+    def failure_tag(self):
+        return safe_force_text(self.original_exception.__class__.__name__)
+
+    def failure_template(self):
+        return safe_force_text(self.original_exception)