pytecplot 1.5.2__py3-none-any.whl

tecplot/tecutil/arglist.py

@@ -0,0 +1,230 @@
+from collections.abc import Iterable
+from collections import OrderedDict, namedtuple
+from enum import Enum
+from ctypes import (c_char, c_char_p, c_double, c_int, c_int64, c_size_t,
+                    c_void_p, byref, cast, pointer, POINTER)
+
+from .tecutil_connector import _tecutil, _tecutil_connector
+from ..exception import *
+from .. import version
+from ..constant import ArgListArgType
+from .stringlist import StringList
+from .index_set import IndexSet
+from .util import Index
+
+
+class RemoteArgList(c_void_p):
+    """Dict-like object holding string,object pairs."""
+    def __init__(self, *args, **kwargs):
+        super().__init__(_tecutil.ArgListAlloc())
+        self._handles = {}
+        self._nargs = 0
+        for a in args:
+            self.update(**a)
+        self.update(**kwargs)
+
+    # data access
+    def _index(self, key):
+        try:
+            success, index = _tecutil.ArgListGetIndexByArgName(self, key)
+            if success:
+                return index - 1
+        except TecplotSystemError:
+            return None
+
+    def _key(self, index):
+        return _tecutil.ArgListGetArgNameByIndex(self, index + 1)
+
+    def _type(self, index):
+        return ArgListArgType(_tecutil.ArgListGetArgTypeByIndex(self, index+1))
+
+    def _item(self, index):
+        get_by_index = {
+            ArgListArgType.ArbParam:    _tecutil.ArgListGetArbParamByIndex,
+            ArgListArgType.ArbParamPtr: _tecutil.ArgListGetArbParamPtrByIndex,
+            ArgListArgType.Array:       _tecutil.ArgListGetArrayByIndex,
+            ArgListArgType.Double:      _tecutil.ArgListGetDoubleByIndex,
+            ArgListArgType.DoublePtr:   _tecutil.ArgListGetDoublePtrByIndex,
+            ArgListArgType.Int:         _tecutil.ArgListGetIntByIndex,
+            ArgListArgType.Set:         _tecutil.ArgListGetSetByIndex,
+            ArgListArgType.String:      _tecutil.ArgListGetStringByIndex,
+            ArgListArgType.StringList:  _tecutil.ArgListGetStringListByIndex,
+            ArgListArgType.StringPtr:   _tecutil.ArgListGetStringPtrByIndex, }
+        item_type = self._type(index)
+        if index in self._handles and item_type is ArgListArgType.Int:
+            return self._handles[index]
+        else:
+            return get_by_index[item_type](self, index + 1)
+
+    def __getitem__(self, key):
+        index = self._index(key)
+        return self._item(index)
+
+    def __setitem__(self, key, val):
+        if __debug__:
+            if key in self.keys():
+                raise TecplotLogicError('Duplicate ArgList key: '+key)
+        # ignore all values set to None.
+        if val is None:
+            return
+        if isinstance(val, StringList):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendStringList(self, key, val)
+        elif isinstance(val, IndexSet):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendSet(self, key, val)
+        elif isinstance(val, str):
+            _tecutil.ArgListAppendString(self, key, val)
+        elif isinstance(val, (float, c_double)):
+            _tecutil.ArgListAppendDouble(self, key, val)
+        elif isinstance(val, POINTER(c_double)):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendDoublePtr(self, key, val)
+        elif isinstance(val, Index):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendInt(self, key, val + 1)
+        elif isinstance(val, (int, bool)):
+            _tecutil.ArgListAppendInt(self, key, val)
+        elif isinstance(val, Enum):
+            _tecutil.ArgListAppendInt(self, key, val.value)
+        elif isinstance(val, c_size_t):
+            _tecutil.ArgListAppendArbParam(self, key,
+                cast(byref(val), POINTER(c_int64)).contents)
+        elif isinstance(val, POINTER(c_size_t)):
+            val = cast(val, POINTER(c_int64))
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendArbParamPtr(self, key, val)
+        elif isinstance(val, POINTER(POINTER(c_char))):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendArbParamPtr(self, key, val)
+        elif isinstance(val, POINTER(c_char_p)):
+            self._handles[self._nargs] = val
+            _tecutil.ArgListAppendStringPtr(self, key, val)
+        else:
+            if isinstance(val, Iterable):
+                val = list(val)
+            if isinstance(val, list):
+                if isinstance(val[0], Enum):
+                    v = (c_int * len(val))(*[e.value for e in val])
+                    self._handles[self._nargs] = v
+                    _tecutil.ArgListAppendArray(self, key, v)
+                elif isinstance(val[0], float):
+                    v = (c_double * len(val))(*val)
+                    self._handles[self._nargs] = v
+                    _tecutil.ArgListAppendArray(self, key, v)
+                elif len(val) == 0 or isinstance(val[0], int):
+                    v = (c_int64 * len(val))(*val)
+                    self._handles[self._nargs] = v
+                    _tecutil.ArgListAppendArray(self, key, v)
+                else:
+                    msg = 'invalid type: {} ({} = {})'
+                    msg = msg.format(type(val), key, val)
+                    raise TecplotTypeError(msg)
+            else:
+                msg = 'invalid type: {} ({} = {})'
+                msg = msg.format(type(val), key, val)
+                raise TecplotTypeError(msg)
+        self._nargs += 1
+
+    def __len__(self):
+        return _tecutil.ArgListGetArgCount(self)
+
+    def keys(self):
+        for index in range(len(self)):
+            yield self._key(index)
+
+    def items(self):
+        for index, key in enumerate(self.keys()):
+            yield key, self._item(index)
+
+    # string representations
+    def __repr__(self):
+        kwargs = []
+        for key, val in self.items():
+            kwargs.append("{key}='{val}'".format(key=key, val=val))
+        return 'ArgList({kwargs})'.format(kwargs=', '.join(kwargs))
+
+    def __str__(self):
+        return str(dict(self))
+
+    # iterating
+    def __iter__(self):
+        self.current_index = -1
+        self.current_length = len(self)
+        return self
+
+    def __next__(self):
+        self.current_index += 1
+        if self.current_index < self.current_length:
+            return self._key(self.current_index)
+        else:
+            del self.current_index
+            del self.current_length
+            raise StopIteration()
+
+    # context management
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.dealloc()
+
+    # public methods
+    def update(self, *args, **kwargs):
+        if len(args) > 1:
+            msg = 'update expected at most 1 arguments, got ' + len(args)
+            raise TypeError(msg)
+        if len(args):
+            try:
+                for k, v in args[0]:
+                    if v is not None:
+                        self[k] = v
+            except TypeError:
+                msg = 'arglist update elements require 2 arguments (key, value)'
+                raise ValueError(msg)
+        for k, v in kwargs.items():
+            if v is not None:
+                self[k] = v
+
+    def clear(self):
+        _tecutil.ArgListClear(self)
+        self._handles = {}
+        self._nargs = 0
+
+    def dealloc(self):
+        _tecutil.ArgListDealloc(pointer(self))
+        self._handles = {}
+        self._nargs = 0
+
+
+class LocalArgList(OrderedDict):
+    def __setitem__(self, key, val):
+        # setting to None deletes existing key
+        if val is None:
+            if key in self.keys():
+                del self[key]
+            return
+
+        accepted_types = tuple([str, StringList, IndexSet, float, c_double,
+            POINTER(c_double), int, bool, Enum, c_size_t, POINTER(c_size_t),
+            POINTER(c_int64), POINTER(POINTER(c_char)), POINTER(c_char_p),
+            Iterable, Index])
+        if not isinstance(val, accepted_types):
+            raise TecplotTypeError(type(val))
+
+        return OrderedDict.__setitem__(self, key, val)
+
+    def __repr__(self):
+        kwargs = []
+        for key, val in self.items():
+            kwargs.append("{key}='{val}'".format(key=key, val=val))
+        return 'ArgList({kwargs})'.format(kwargs=', '.join(kwargs))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.clear()
+
+    def dealloc(self):
+        self.clear()

tecplot/tecutil/captured_output.py

@@ -0,0 +1,177 @@
+import os
+import sys
+
+from contextlib import contextmanager
+from io import TextIOWrapper, UnsupportedOperation
+from tempfile import TemporaryFile
+
+try:
+    import ctypes
+    import platform
+    from ctypes.util import find_library
+    if platform.system() == 'Windows':
+        from ctypes.util import find_msvcrt
+        msvcrt = find_msvcrt()
+        if msvcrt is not None:
+            libc = ctypes.cdll[msvcrt]
+        else:
+            libc = ctypes.cdll.msvcrt
+    elif platform.system() in ['Mac', 'Darwin']:
+        libc = ctypes.CDLL(find_library('c'))
+    else: # if platform.system() in ['Linux']:
+        libc = ctypes.CDLL(None)
+except ImportError: # pragma: no cover
+    libc = None
+
+
+@contextmanager
+def captured_output(out=os.devnull, err=None, mode='wb', errmode=None):
+
+    if platform.system() == 'Windows':
+        yield
+        return
+
+    err = out if err is None else err
+    errmode = mode if errmode is None else errmode
+
+    def open_stream(target):
+        try:
+            stream = open(target, mode)
+            fd = stream.fileno()
+            istemp = True
+            isbuff = False
+        except TypeError:
+            try:
+                fd = target.fileno()
+                stream = target
+                istemp = False
+                isbuff = False
+            except (AttributeError, UnsupportedOperation):
+                stream = TemporaryFile(mode='w+b')
+                fd = stream.fileno()
+                istemp = True
+                isbuff = True
+        return stream, fd, istemp, isbuff
+
+    try:
+        # flush all output streams
+        if libc is not None:
+            libc.fflush(None)
+
+        if (sys.stdout is not None) and (out is not None):
+            ### stdout
+            redirected_stdout = sys.stdout is not sys.__stdout__
+            # save previous output stream
+            _sys_stdout = sys.__stdout__
+            _sys_stdout_fd = _sys_stdout.fileno()
+            _sys_stdout_fd_dup = os.dup(_sys_stdout_fd)
+            # flush pending output
+            _sys_stdout.flush()
+            if redirected_stdout:
+                sys.stdout.flush()
+            out_stream, out_fd, out_istemp, out_isbuff = open_stream(out)
+            # overwrite file objects and low-level file descriptors
+            os.dup2(out_fd, _sys_stdout_fd)
+            if redirected_stdout:
+                _saved_stdout = sys.stdout
+                sys.stdout = os.fdopen(os.dup(out_fd),'wb')
+                sys.stdout = TextIOWrapper(sys.stdout)
+
+        if (sys.stderr is not None) and (err is not None):
+            ### stderr
+            redirected_stderr = sys.stderr is not sys.__stderr__
+            # save previous output stream
+            _sys_stderr = sys.__stderr__
+            _sys_stderr_fd = _sys_stderr.fileno()
+            _sys_stderr_fd_dup = os.dup(_sys_stderr_fd)
+            # flush pending output
+            _sys_stderr.flush()
+            if redirected_stderr:
+                sys.stderr.flush()
+            if err is out:
+                err_stream,err_fd,err_istemp,err_isbuff = out_stream,out_fd,False,False
+            else:
+                err_stream,err_fd,err_istemp,err_isbuff = open_stream(err)
+            # overwrite file objects and low-level file descriptors
+            os.dup2(err_fd, _sys_stderr_fd)
+            if redirected_stderr:
+                _saved_stderr = sys.stderr
+                sys.stderr = os.fdopen(os.dup(err_fd),'wb')
+                sys.stderr = TextIOWrapper(sys.stderr)
+
+    finally:
+        try:
+            yield
+
+        finally:
+
+            # flush all output streams
+            if libc is not None:
+                libc.fflush(None)
+
+            if (sys.stdout is not None) and (out is not None):
+                ### restore stdout
+                _sys_stdout.flush()
+                if redirected_stdout:
+                    sys.stdout.flush()
+                # restore original streams and file descriptors
+                os.dup2(_sys_stdout_fd_dup, _sys_stdout_fd)
+                if redirected_stdout:
+                    sys.stdout.close()
+                    sys.stdout = _saved_stdout
+                else:
+                    sys.stdout = _sys_stdout
+                os.close(_sys_stdout_fd_dup)
+
+
+            if (sys.stderr is not None) and (err is not None):
+                ### restore stderr
+                _sys_stderr.flush()
+                if redirected_stderr:
+                    sys.stderr.flush()
+                # restore original streams and file descriptors
+                os.dup2(_sys_stderr_fd_dup, _sys_stderr_fd)
+                if redirected_stderr:
+                    sys.stderr.close()
+                    sys.stderr = _saved_stderr
+                else:
+                    sys.stderr = _sys_stderr
+                os.close(_sys_stderr_fd_dup)
+
+
+            if (sys.stdout is not None) and (out is not None):
+                if out_isbuff:
+                    out_stream.seek(0)
+                    out_bytes = out_stream.read()
+                    if len(out_bytes):
+                        try:
+                            out.write(out_bytes)
+                        except:
+                            out_str = out_bytes.decode().strip()
+                            try:
+                                out.write(out_str)
+                            except:
+                                out_msg = 'captured output:\n{0}'.format('  '+out_str.replace('\n','\n  '))
+                                out(out_msg)
+
+                if out_istemp:
+                    out_stream.close()
+
+            if (sys.stderr is not None) and (err is not None):
+                if err is not out:
+                    if err_isbuff:
+                        err_stream.seek(0)
+                        err_bytes = err_stream.read()
+                        if len(err_bytes):
+                            try:
+                                err.write(err_bytes)
+                            except:
+                                err_str = err_bytes.decode().strip()
+                                try:
+                                    err.write(err_str)
+                                except:
+                                    err_msg = 'captured output:\n{0}'.format('  '+err_str.replace('\n','\n  '))
+                                    err(err_msg)
+
+                    if err_istemp:
+                        err_stream.close()