def _get_extension_by_index(index, extensions):
"""
Get the path to a module at position index in the passed lists of paths (extensions) and load it.
Return the loaded module.
@param index a position in the extensions array
@param extensions a list of paths to python modules (usually self._serializers or self._deserializers)
@return the module loaded from the specified path
"""
if index >= len(extensions):
return None
type_extension = extensions[index]
if not isinstance(type_extension, types.ModuleType):
path = type_extension
last_separator = path.rfind(os.sep)
file_extension_start = path.rfind('.')
module_name = path[last_separator + 1:file_extension_start]
try:
if EnvironmentHelper.is_python3():
type_extension = importlib.machinery.SourceFileLoader(
module_name, path).load_module()
else:
type_extension = imp.load_source(module_name, path)
except ImportError as error:
raise ImportError(
'Error while loading python type extension ' +
module_name + '\nCause: ' + str(error))
extensions[index] = type_extension
return type_extension
def check_required_modules(self, additional_required_modules=None):
"""
:param additional_required_modules: A list of 5-tuples (module_name, min_version, min_inclusive, max_version,
max_inclusive) that specifies additional required modules to test. The list may be None. All tuple entries but
module_name may be None.
"""
# Python standard modules.
# TODO: Does it really make sense to test those?!
if EnvironmentHelper.is_python3():
self.check_module('io')
else:
self.check_module('StringIO')
self.check_module('datetime', class_names=['datetime'])
self.check_module('math')
self.check_module('socket')
self.check_module('struct')
self.check_module('base64')
self.check_module('traceback')
self.check_module('os')
self.check_module('pickle')
self.check_module('imp')
self.check_module('types')
# Non-standard modules.
self.check_module('numpy')
global _default_min_pandas_version
min_pandas_version = _default_min_pandas_version
self.check_module('pandas',
min_version=min_pandas_version,
class_names=['DataFrame'])
# Additional modules.
if additional_required_modules is not None:
self.check_additional_modules(additional_required_modules)
def _respond(self, request, response_message_id, workspace):
name = PayloadDecoder(request.payload).get_next_string()
image = workspace.get_variable_or_default(name, None)
if EnvironmentHelper.is_python3():
if type(image) is bytes:
data_bytes = image
else:
data_bytes = bytearray()
else:
if type(image) is str:
data_bytes = image
else:
data_bytes = ''
return AbstractRequestHandler._create_response(request, response_message_id,
response_payload=_create_byte_array_payload(data_bytes))
def _standardize_input(notebook_directory, notebook_name, notebook_version, only_include_tag):
if notebook_directory is None:
raise ValueError("Notebook directory must not be None.")
if notebook_name is None:
raise ValueError("Notebook name must not be None.")
notebook_directory = str(notebook_directory)
notebook_name = str(notebook_name)
notebook_path = None
if notebook_directory.startswith("knime:"):
exception = None
try:
notebook_path = posixpath.join(notebook_directory, notebook_name)
notebook_path = _resolve_knime_url(notebook_path)
except Exception as ex:
exception = ex
if exception is not None:
# Raise exception outside of the original catch block to avoid polluting the console with the full
# traceback.
raise ValueError(str(exception))
if not EnvironmentHelper.is_python3():
# Java always returns a unicode string, Python 2 wants non-unicode.
notebook_path = str(notebook_path)
else:
notebook_path = os.path.join(notebook_directory, notebook_name)
if not os.path.isfile(notebook_path):
raise ValueError("Notebook path '" + notebook_path + "' does not point to an existing file.")
if notebook_version is None:
notebook_version = NO_CONVERT
else:
try:
notebook_version = int(notebook_version)
except ValueError:
notebook_version = None
# Raise exception outside of the original catch block to avoid polluting the console with the full traceback.
if notebook_version is None:
raise ValueError("Notebook version must be an integer or castable to an integer.")
if only_include_tag is not None:
only_include_tag = str(only_include_tag)
return notebook_path, notebook_version, only_include_tag
def load_module_from_path(path):
"""
Load a python module from a source file.
@param path the path to the source file (string)
@return the module loaded from the specified path
"""
last_separator = path.rfind(os.sep)
file_extension_start = path.rfind('.')
module_name = path[last_separator + 1:file_extension_start]
try:
if EnvironmentHelper.is_python3():
loaded_module = importlib.machinery.SourceFileLoader(
module_name, path).load_module()
else:
loaded_module = imp.load_source(module_name, path)
except ImportError as error:
raise ImportError('Error while loading python module ' + module_name +
'\nCause: ' + str(error))
return loaded_module
def object_to_string(data_object):
"""
Convert data_object to a (possibly truncated) string representation.
"""
if EnvironmentHelper.is_python3():
try:
object_as_string = str(data_object)
except Exception:
return ''
else:
try:
object_as_string = unicode(data_object)
except UnicodeDecodeError:
object_as_string = '(base64 encoded)\n' + base64.b64encode(
data_object)
except Exception:
return ''
return (object_as_string[:996] +
'\n...') if len(object_as_string) > 1000 else object_as_string
def list_variables(self):
"""
List all currently loaded modules and defined classes, functions and variables.
"""
# create lists of modules, classes, functions and variables
modules = []
classes = []
functions = []
variables = []
# iterate over dictionary to and put modules, classes, functions and variables in their respective lists
for key, value in dict(self._exec_env).items():
# get name of the type
var_type = type(value).__name__
# class type changed from classobj to type in python 3
class_type = 'classobj'
if EnvironmentHelper.is_python3():
class_type = 'type'
if var_type == 'module':
modules.append({'name': key, 'type': var_type, 'value': ''})
elif var_type == class_type:
classes.append({'name': key, 'type': var_type, 'value': ''})
elif var_type == 'function':
functions.append({'name': key, 'type': var_type, 'value': ''})
elif key != '__builtins__':
value = object_to_string(value)
variables.append({
'name': key,
'type': var_type,
'value': value
})
# sort lists by name
modules = sorted(modules, key=lambda k: k['name'])
classes = sorted(classes, key=lambda k: k['name'])
functions = sorted(functions, key=lambda k: k['name'])
variables = sorted(variables, key=lambda k: k['name'])
# create response list and add contents of the other lists in the order they should be displayed
response = []
response.extend(modules)
response.extend(classes)
response.extend(functions)
response.extend(variables)
return response
# prepare and propagate Nodes, in each case even if such Nodes are
# propagated with or for interoperation with KNIME. The owner of a Node
# may freely choose the license terms applicable to such Node, including
# when such Node is propagated with or for interoperation with KNIME.
# ------------------------------------------------------------------------
"""
@author Clemens von Schwerin, KNIME GmbH, Konstanz, Germany
@author Patrick Winter, KNIME GmbH, Konstanz, Germany
@author Marcel Wiedenmann, KNIME GmbH, Konstanz, Germany
@author Christian Dietz, KNIME GmbH, Konstanz, Germany
"""
# This should be the first statement in each module that makes specific demands on the Python environment.
import EnvironmentHelper
if EnvironmentHelper.is_python3():
import importlib
else:
import imp
if EnvironmentHelper.is_tslib_available():
from EnvironmentHelper import Timestamp
from EnvironmentHelper import NaT
else:
Timestamp = None
NaT = None
import base64
import inspect
import math
import numpy