psevencore 2024.3.21__py2.py3-none-win_amd64.whl

da/__init__.py

@@ -0,0 +1,194 @@
+#
+# coding: utf-8
+# Copyright (C) pSeven SAS, 2010-present
+#
+
+"""
+Init script for group of projects with version support.
+
+This '__init__' script is intended to handle namespace-like package that in general combines different
+projects - subpackages. Such subprojects may reside in different directories. Moreover there can be different
+versions of single project. In any case this script will initialize multi directory package, will find the most
+recent versions of existing subprojects and will initialize the routine which will import latest subproject if the
+version is not explicitly specified.
+
+It is much simpler to illustrate by an example.
+
+Consider we have the following directories located in different places and each 'group' dir is pointed by the PYTHONPATH.
+
+- A/group/prj1_1_0_0  # project 1 version 1.0.0
+         /prj2_1_0_0  # project 2 version 1.0.0
+         /__init__.py # this '__init__.py' file
+- B/group/prj1_1_0_1  # project 1 version 1.0.1
+         /__init__.py # this '__init__.py' file
+
+In that case we will get desired behaviour - latest versions will be imported by default:
+
+> from group import prj1
+> print prj1
+<module 'group.prj1_1_0_1' from '../B/group/prj1_1_0_1/__init__.pyc'>
+
+> from group import prj2
+> print prj2
+<module 'group.prj2_1_x_x' from '../C/group/prj2_1_x_x/__init__.pyc'>
+
+At the same time you can explicitly import some particular version:
+> from group import prj1_1_0_0
+> print prj1_1_0_0
+<module 'group.prj1_1_0_0' from '../A/group/prj1_1_0_0/__init__.pyc'>
+
+Typically, the 'group' in the example above is the company name or some metaproject name.
+
+We assume that subpackages have the following naming scheme: '<package_name>_<version>',
+where 'version' starts with a digit, and 'package_name' does not contain any digit with a preceding underscore.
+"""
+
+# add to the package's __path__ all subdirectories of directories on sys.path named after the package
+from __future__ import with_statement
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+class _pSevenModuleHook(object):
+  class _LegacyLoader(object):
+    def __init__(self, module_path, module_code):
+      self.module_path = module_path
+      self.module_code = module_code
+
+    def load_module(self, fullname):
+      import sys
+
+      new_module = None
+
+      try:
+        import os
+        import imp
+
+        if fullname not in sys.modules:
+          new_module = imp.new_module(fullname)
+          sys.modules[fullname] = new_module
+
+        module = sys.modules.get(fullname)
+        module.__file__ = os.path.join(self.module_path, "__init__.py")
+        module.__name__ = fullname
+        module.__path__ = [self.module_path]
+        module.__loader__ = self
+        module.__package__ = fullname
+
+        exec(self.module_code, module.__dict__)
+
+        return module
+      except:
+        exc_value = sys.exc_info()[1]
+
+      if new_module is not None:
+        sys.modules.pop(fullname, None)
+
+      raise ImportError(exc_value)
+
+  def __init__(self, root_name):
+    self._root_name = root_name
+    self._modules = {}
+
+  def __repr__(self):
+    return "pSeven Core Package Finder"
+
+  def _append(self, fullname, dirname):
+    self._modules[self._root_name + "." + fullname] = dirname
+
+  def find_spec(self, fullname, path, target=None):
+    # The modern spec-based module finder.
+    origin_module = self._modules.get(fullname)
+    if not path or not origin_module:
+      return None
+
+    import os
+    from importlib.util import spec_from_file_location
+
+    for module_dir in path:
+      try:
+        module_path = os.path.join(module_dir, origin_module)
+        module_init = os.path.join(module_path, "__init__.py")
+        if os.path.exists(module_init):
+          return spec_from_file_location(name=fullname, location=module_init, submodule_search_locations=[module_path])
+      except:
+        pass
+
+    return None
+
+  def find_module(self, fullname, path):
+    # Good old PEP 302 module finder
+    if not path:
+      return None
+
+    origin_module = self._modules.get(fullname)
+    if not origin_module:
+      return None
+
+    try:
+      import os
+
+      for module_dir in path:
+        module_path = os.path.join(module_dir, origin_module)
+        try:
+          with open(os.path.join(module_path, "__init__.py"), "r") as fid:
+            module_code = fid.read(-1)
+          return self._LegacyLoader(module_path, module_code)
+        except:
+          pass
+    except:
+      pass
+
+    return None
+
+
+def initialize_current_package():
+  def _optional_int(value):
+    try:
+      return int(value)
+    except:
+      pass
+    return value
+
+  import sys
+  import pkgutil
+  import re
+
+  versions = {}
+  loaders = {}
+  re_name = re.compile(r"^([A-Za-z0-9_]+?)_([0-9x]+.*)$")
+
+  finder = _pSevenModuleHook(__name__)
+
+  # iterate through all the subpackages located inside package directories
+  for _, name_with_version, _ in pkgutil.iter_modules(__path__):
+    try:
+      # skip subpackages/submodules which names do not correspond to the naming rule
+      match = re_name.match(name_with_version)
+      if match is None:
+        continue
+
+      version = tuple(_optional_int(_) for _ in match.group(2).split('_'))
+
+      for basename in (match.group(1), "macros"):
+        finder._append(basename + "_" + match.group(2), name_with_version)
+
+        # collect information about the latest version
+        if versions.get(basename, (0,0,0)) <= version:
+          versions[basename] = version
+          loaders[basename] = name_with_version
+    except:
+      pass
+
+  # install import hooks, which will handle the latest version as the default version
+  for basename in loaders:
+    finder._append(basename, loaders[basename])
+
+  sys.meta_path.append(finder)
+
+initialize_current_package()
+
+# cleanup the namespace
+del initialize_current_package
+del with_statement
+del _pSevenModuleHook
+

da/p7core_2024_3_21/FindNative.py

@@ -0,0 +1,215 @@
+#
+# coding: utf-8
+# Copyright (C) pSeven SAS, 2010-present
+#
+
+"""Supplementary python functions."""
+
+import sys
+import os
+import platform
+import re
+import ctypes
+
+def _platformInfo():
+  """Get platform info."""
+  (sysname, nodename, release, version, machine, processor) = platform.uname()
+
+  try:
+    machine = 'x64' if ctypes.sizeof(ctypes.c_void_p) > 4 else 'x86'
+  except:
+    machine = 'x64' if platform.architecture()[0] == '64bit' else 'x86'
+
+  suffix = str()
+  if sysname == 'Linux':
+    suffix = 'so'
+  elif sysname == 'Windows':
+    suffix = 'dll'
+  else:
+    raise Exception('Unsupported system!')
+  return sysname.lower(), machine, suffix
+
+
+def _searchLib(libname, libpath, platform_info=None):
+  """Searches specific directory for a native library with platform-dependent name.
+
+  :param libname: library basename
+  :param libpath: path to look in
+  :param platform_info: (optional) platform tuple (sysname, machine, suffix)
+  """
+  try:
+    sysname, machine, suffix = _platformInfo() if platform_info is None else platform_info
+    return sorted([os.path.join(libpath, fname) for fname in os.listdir(libpath) \
+      if re.match(r'^(lib)?%s-2024.3.21-%s-%s-[^-]+(-s)?(-dbg)?\.%s$' % (libname, sysname, machine, suffix), fname) != None], \
+      reverse=True)
+  except OSError:
+    return []
+
+
+def _searchPy(libname, libpath):
+  """Searches specific directory for a python module.
+
+  :param libname: module name
+  :param libpath: path to look in
+  """
+  try:
+    files = os.listdir(libpath)
+    files = list([f for f in files if ('%s.py' % libname) == f])
+  except OSError:
+    files = []
+  return libpath if files else None
+
+def _searchPyDir(dirname, libpath):
+  """Searches specific directory for a python package.
+
+  :param dirname: package name
+  :param libpath: path to look in
+  """
+  try:
+    entities = [os.path.join(libpath, fpath) for fpath in os.listdir(libpath) if fpath == dirname]
+    entities = [fpath for fpath in entities if os.path.isdir(fpath)]
+  except OSError:
+    entities = []
+  return libpath if entities else None
+
+
+def appendModulePath(libname, prefix=None, maxLevel=4, root=None):
+  """Searches for a "libname" python module in any 'python' directories.
+
+  The search starts from root (from __file__ parent directory if none provided) and up + in current directory.
+  :param libname: module name
+  :param prefix: additional prefix to bin/lib directories
+  :param maxLevel: maximum 'steps' up the directory tree
+  :param root: start search from here
+  """
+  if not root:
+    root = os.path.dirname(os.path.realpath(__file__))
+
+  pdir = _searchPy(libname, root)
+  if prefix and not pdir:
+    searchpath = os.path.join(root, prefix)
+    pdir = _searchPy(libname, searchpath)
+
+  currentRoot = root
+  currentLevel = 0
+  while not pdir and (currentLevel < maxLevel):
+    pdir = _searchPy(libname, os.path.join(currentRoot, 'python'))
+    if prefix and not pdir:
+      searchpath = os.path.join(currentRoot, prefix)
+      pdir = _searchPy(libname, os.path.join(searchpath, 'python'))
+    try:
+      currentRoot = os.path.split(currentRoot)[0]
+    except:
+      break
+    currentLevel = currentLevel + 1
+  if not pdir:
+    raise Exception('Cannot find "%s" python module!'  % libname)
+  sys.path.append(pdir)
+
+
+def appendPackagePath(libname, prefix=None, maxLevel=4, root=None):
+  """Searches for a "libname" python package in any 'python' directories.
+
+  The search starts from root (from __file__ parent directory if none provided) and up + in current directory.
+  :param libname: module name
+  :param prefix: additional prefix to bin/lib directories
+  :param maxLevel: maximum 'steps' up the directory tree
+  :param root: start search from here
+  """
+  if not root:
+    root = os.path.dirname(os.path.realpath(__file__))
+  pdir = _searchPyDir(libname, root)
+
+  if prefix and not pdir:
+    searchpath = os.path.join(root, prefix)
+    pdir = _searchPyDir(libname, searchpath)
+
+  currentRoot = root
+  currentLevel = 0
+  while not pdir and (currentLevel < maxLevel):
+    pdir = _searchPyDir(libname, os.path.join(currentRoot, 'python'))
+    if prefix and not pdir:
+      searchpath = os.path.join(currentRoot, prefix)
+      pdir = _searchPyDir(libname, searchpath)
+    try:
+      currentRoot = os.path.split(currentRoot)[0]
+    except:
+      break
+    currentLevel = currentLevel + 1
+  if not pdir:
+    raise Exception('Cannot find "%s" python package!' % libname)
+  sys.path.append(pdir)
+
+
+def loadNativeLib(libname, prefix=None, maxLevel=4, root=None):
+  """Search for a "libname" native library in any 'bin' and 'lib' directories.
+
+  The search starts from root (from __file__ parent directory if none provided) and up + in current directory.
+
+  .. note::
+
+  Requires ctypes!
+
+  :param libname: module name
+  :param prefix: additional prefix to bin/lib directories
+  :param maxLevel: maximum 'steps' up the directory tree
+  :param root: start search from here
+  """
+  if not root:
+    root = os.path.dirname(os.path.realpath(__file__))
+
+  def search_libs(root, platform_info):
+    libs = _searchLib(libname, root, platform_info)
+    if prefix and not libs:
+      searchpath = os.path.join(root, prefix)
+      libs = _searchLib(libname, searchpath)
+    currentRoot = root
+
+    currentLevel = 0
+    def scanlibpaths(searchpath):
+      libs = _searchLib(libname, os.path.join(searchpath, 'lib'), platform_info)
+      if not libs:
+        libs = _searchLib(libname, os.path.join(searchpath, 'bin'), platform_info)
+      if not libs:
+        libs = _searchLib(libname, os.path.join(searchpath, 'bin', sysname + '-' + machine), platform_info)
+      return libs
+
+    while not libs and (currentLevel < maxLevel):
+      libs = scanlibpaths(currentRoot)
+      if not libs and prefix:
+        libs = scanlibpaths(os.path.join(currentRoot, prefix))
+      try:
+        currentRoot = os.path.split(currentRoot)[0]
+      except:
+        break
+      currentLevel = currentLevel + 1
+    return libs
+
+  sysname, machine, suffix = _platformInfo()
+  libs = search_libs(root, (sysname, machine, suffix))
+
+  if not libs:
+    raise Exception('Cannot find "%s" native library!' % libname)
+
+  library = None
+
+  try:
+    origCwd = os.getcwdu()
+  except AttributeError:
+    origCwd = os.getcwd()
+
+  for lib in libs:
+    try:
+      os.chdir(os.path.dirname(lib))
+      try:
+        library = ctypes.CDLL(lib)
+        if library:
+          message = 'Loaded "%s" library at path "%s"' % (libname, lib)
+          break
+      except:
+        pass
+    finally:
+      os.chdir(origCwd)
+  if not library:
+    message = 'No loaded "%s" library' % libname
+  return library, message

da/p7core_2024_3_21/__init__.py

@@ -0,0 +1,59 @@
+#
+# coding: utf-8
+# Copyright (C) pSeven SAS, 2010-present
+#
+
+"""pSeven Core package."""
+
+__version__ = "2024.3.21"
+
+import numpy
+import ctypes as _ctypes
+import atexit as _atexit
+
+def _distutils_loose_version(vstring):
+  import re
+  vlist = []
+  for c in re.split(r'(\d+ | [a-z]+ | \.)', str(vstring), flags=re.VERBOSE):
+    if c and c != '.':
+      try:
+        c = int(c)
+      except:
+        pass
+      vlist.append(c)
+  return tuple(vlist)
+
+if _distutils_loose_version(numpy.version.version) < (1,6,0):
+  raise Exception('The detected version of numpy is %s. NumPy version 1.6.0 or newer is required to run pSeven Core.' % (numpy.version.version))
+
+from . import FindNative as _FindNative
+_FindNative._library, _FindNative._library_welcome_message = _FindNative.loadNativeLib('generic_tools')
+if not _FindNative._library:
+  raise RuntimeError('Failed to load "generic_tools" backend library.')
+
+_ctypes.CFUNCTYPE(_ctypes.c_void_p)(("GTWarmUp", _FindNative._library))()
+
+_shutdown = _ctypes.CFUNCTYPE(_ctypes.c_void_p)(("GTShutDown", _FindNative._library))
+_atexit.register(_shutdown)
+
+from . import shared as _shared
+from .options import Options
+from .license import License
+from .parameters import Parameters
+from .exceptions import Exception, GTException, XTException, InvalidOptionsError, InvalidOptionNameError,\
+                        InvalidOptionValueError, InvalidProblemError, FeatureNotAvailableError, InfeasibleProblemError,\
+                        UnsupportedProblemError, NanInfError, InternalError, OutOfMemoryError, UserTerminated, WrongUsageError,\
+                        LicenseError, IllegalStateError, InapplicableTechniqueException, ExceptionWrapper, BBPrepareException,\
+                        UserEvaluateException, WatcherException, LoggerException
+from . import gtapprox
+from . import gtdf
+from . import gtdoe
+from . import gtdr
+from . import gtsda
+from . import gtopt
+from . import stat
+from .result import Result
+
+_NONE = _shared._NONE
+
+__all__ = ['gtapprox', 'gtdf', 'gtdoe', 'gtdr', 'gtsda', 'gtopt', 'stat']

da/p7core_2024_3_21/archives.py

@@ -0,0 +1,137 @@
+#
+# coding: utf-8
+# Copyright (C) pSeven SAS, 2010-present
+#
+
+from __future__ import with_statement
+from __future__ import division
+
+import sys as _sys
+import os as _os
+import time as _time
+import contextlib as _contextlib
+import zipfile as _zipfile
+import tarfile as _tarfile
+import codecs as _codecs
+
+from . import shared as _shared
+
+
+@_contextlib.contextmanager
+def _with_zipfile(file, *args, **kwargs):
+  obj = _zipfile.ZipFile(file, *args, **kwargs)
+  try:
+    yield obj
+  finally:
+    obj.close()
+
+@_contextlib.contextmanager
+def _with_tarfile(file, *args, **kwargs):
+  obj = _tarfile.open(file, *args, **kwargs)
+  try:
+    yield obj
+  finally:
+    obj.close()
+
+def _detect_tar_mode(filename):
+  tar_codes = ((".tar", "w"), (".tgz", "w:gz"), (".tar.gz", "w:gz"), (".taz", "w:gz"), (".tbz", "w:bz2"), (".tbz2", "w:bz2"), (".tar.bz2", "w:bz2"))
+  for tar_ext, tar_mode in tar_codes:
+    ext_pos = -len(tar_ext)
+    if filename[ext_pos:].lower() == tar_ext:
+      return filename[:ext_pos], tar_mode
+  return filename, None
+
+class _BasicArchveWriter(object):
+  def __init__(self, file_obj):
+    self.pending_error = None
+    self.file_obj = file_obj
+
+  def process_exception(self):
+    if self.pending_error is None:
+      self.pending_error = _sys.exc_info()
+
+  def flush_callback_exceptions(self, succeeded, model_error):
+    if self.pending_error is not None:
+      exc_type, exc_val, exc_tb = self.pending_error
+      if model_error is not None and model_error[1]:
+        exc_val = ("%s The origin of the exception is: %s" % (_shared._safestr(model_error[1]).strip(), _shared._safestr(exc_val).strip())) if exc_val else model_error[1]
+      _shared.reraise(exc_type, exc_val, exc_tb)
+
+    if model_error is not None and model_error[0] is not None:
+      raise model_error[0](model_error[1] or ("Failed to save model as zip-compressed multiply %s source files." % ExportedFormat.to_string(format)))
+
+class _ZipArchiveWriter(_BasicArchveWriter):
+  def __call__(self, archname, bytes):
+    try:
+      self.file_obj.writestr(_shared._preprocess_utf8(archname), bytes, _zipfile.ZIP_DEFLATED)
+      return True
+    except:
+      self.process_exception()
+    return False
+
+class _SequentialReader(object):
+  def __init__(self, data, size=None):
+    self.data = data
+    self.size = len(data) if size is None else size
+
+  def read(self, size=-1):
+    size = self.size if (size is None or size < 0) else min(size, self.size)
+    data_block = self.data[:size]
+    self.data = self.data[size:]
+    self.size -= size
+    return data_block
+
+class _TarArchiveWriter(_BasicArchveWriter):
+  def __call__(self, archname, bytes):
+    try:
+      info = _tarfile.TarInfo(_shared._preprocess_utf8(archname))
+      info.size = len(bytes)
+      info.mode = 438 # chmod a+rw
+      info.mtime = _time.time()
+      self.file_obj.addfile(info, _SequentialReader(bytes, info.size))
+      return True
+    except:
+      self.process_exception()
+    return False
+
+class _DirectoryWriter(_BasicArchveWriter):
+  def __init__(self, directory, fixed_filename):
+    super(_DirectoryWriter, self).__init__(None)
+    self.directory = directory
+    self.filename = fixed_filename
+
+  @staticmethod
+  def _create_path(dirname):
+    if not dirname or _os.path.exists(dirname):
+      return
+
+    try:
+      _os.makedirs(dirname)
+    except:
+      exc_type, exc_val, exc_tb = _sys.exc_info()
+      _shared.reraise(exc_type, ('Failed to create directory "%s": %s' % (dirname, exc_val)), exc_tb)
+
+  def __call__(self, archname, bytes):
+    try:
+      archname = _os.path.join(self.directory, _shared._preprocess_utf8(archname))
+
+      self._create_path(_os.path.split(archname)[0])
+      with _codecs.open(self.filename or archname, "w", encoding="utf8") as fobj:
+        fobj.write(_shared._preprocess_utf8(bytes))
+      return True
+    except:
+      self.process_exception()
+    return False
+
+class _MemoryFileWriter(_BasicArchveWriter):
+  def __init__(self):
+    super(_MemoryFileWriter, self).__init__(None)
+    self.files = []
+
+  def __call__(self, archname, bytes):
+    try:
+      self.files.append((_shared._preprocess_utf8(archname), _shared._preprocess_utf8(bytes)))
+      return True
+    except:
+      self.process_exception()
+    return False

da/p7core_2024_3_21/batch/__init__.py

@@ -0,0 +1,17 @@
+#
+# coding: utf-8
+# Copyright (C) pSeven SAS, 2010-present
+#
+# ssh/cluster utils
+
+from . batch_manager import BatchJobSpecification, BatchJobStatus, SSHBatchManager
+from . utils import test_ssh_connection
+
+__all__ = ['BatchJobSpecification', 'BatchJobStatus', 'SSHBatchManager', 'test_ssh_connection']
+
+try:
+  # this module is optional while it requires paramiko
+  from . command import SSHException, TransportException, TransportAuthenticationException, Command, LocalTransport, SSHTransport
+  __all__.extend(('SSHException', 'TransportException', 'TransportAuthenticationException', 'Command', 'LocalTransport', 'SSHTransport'))
+except:
+  pass