Upload 14 files

pystata/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import absolute_import, print_function
+
+import sys
+
+def _check_python_version():
+    if not sys.version_info >= (3, 4) and not sys.version_info >= (2, 7):
+        raise ImportError("""
+pystata only supports Python 2.7 and 3.4+.
+        """)
+
+_check_python_version()
+del _check_python_version
+
+from .version import version as __version__
+from .version import author as __author__
+
+from . import config

pystata/config.py

@@ -0,0 +1,705 @@
+'''
+This module is used to configure the system and display current system information 
+and settings.
+'''
+from __future__ import absolute_import, print_function
+from ctypes import cdll, c_char_p, c_int, POINTER
+import os
+from os.path import dirname
+import sys
+import platform
+from pystata.stexception import IPythonError, IPyKernelError
+import codecs
+import atexit
+
+def _find_lib(st_home, edition, os_system):
+    lib_name = ""	
+    if os_system == 'Windows':
+        lib_name += (edition + '-64')
+        lib_name += '.dll'
+        lib_path = os.path.join(st_home, lib_name)
+        if os.path.isfile(lib_path):
+            return lib_path
+    elif os_system == 'Darwin':
+        lib_name += 'libstata'
+        lib_name += ('-' + edition)
+        lib_name += '.dylib'
+
+        if edition == 'be':
+            lib_name = os.path.join("StataBE.app/Contents/MacOS", lib_name)
+        elif edition == "se":
+            lib_name = os.path.join("StataSE.app/Contents/MacOS", lib_name)
+        else:
+            lib_name = os.path.join("StataMP.app/Contents/MacOS", lib_name)
+
+        lib_path = os.path.join(st_home, lib_name)
+        if os.path.isfile(lib_path):
+            return lib_path
+    else:
+        lib_name += 'libstata'
+
+        if edition != 'be':
+            lib_name += ('-' + edition)
+
+        lib_name += '.so'
+        lib_path = os.path.join(st_home, lib_name)
+        if os.path.isfile(lib_path):
+            return lib_path
+
+        lib_path = os.path.join('../distn/linux64', lib_name)
+        lib_path = os.path.join(st_home, lib_path)
+        if os.path.isfile(lib_path):
+            return lib_path
+
+        lib_path = os.path.join('../distn/linux.64p', lib_name)
+        lib_path = os.path.join(st_home, lib_path)
+        if os.path.isfile(lib_path):
+            return lib_path
+
+        lib_path = os.path.join('../distn/linux.64', lib_name)
+        lib_path = os.path.join(st_home, lib_path)
+        if os.path.isfile(lib_path):
+            return lib_path
+
+    return None
+
+
+def _get_lib_path(st_home, edition):
+    if st_home is None:
+        raise ValueError('Stata home directory is None')
+    else:
+        if not os.path.isdir(st_home):
+            raise ValueError('Stata home directory is invalid')
+
+    os_system = platform.system()
+    if edition not in ['be','se','mp']:
+        raise ValueError('Stata edition must be one of be, se, or mp')
+
+    lib_path = _find_lib(st_home, edition, os_system)
+    if lib_path is not None:
+        return lib_path
+
+    raise FileNotFoundError('The system cannot find the shared library within the specified path: %s', st_home)
+
+
+def _RaiseSystemException(msg):
+    raise SystemError(msg)
+
+
+stlib = None
+stversion = ''
+stedition = ''
+stinitialized = False
+sfiinitialized = False
+stlibpath = None
+stipython = 0
+stoutputf = None
+
+stconfig = {
+    "grwidth": ['default', 'in'],
+    "grheight": ['default', 'in'],
+    "grformat": 'svg',
+    "grshow": True,
+    "streamout": 'on'
+}
+
+pyversion = sys.version_info[0:3]
+
+
+def _check_duplicate_kmp(edition):
+    os_system = platform.system()
+
+    if edition is None or edition=='mp':
+        if os_system == 'Darwin':
+            os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
+
+def _get_stata_edition(edition):
+    if edition is None:
+        return 'MP'
+    elif edition=='mp': 
+        return 'MP'
+    elif edition=='se':
+        return 'SE'
+    else:
+        return 'BE'
+
+
+def get_encode_str(s):
+    return s.encode('utf-8')
+
+
+def _print_greeting_message(msg):
+    global pyversion
+
+    try:
+        print(msg, end='')
+    except UnicodeEncodeError:
+        if pyversion[0] < 3:
+            print(s.encode('utf-8'), end='')
+        else:
+            print(s.encode('utf-8').decode(sys.stdout.encoding), end='')
+
+
+def backslashreplace_py2(err):
+    s = err.object
+    start = err.start
+    end = err.end
+
+    def backslashreplace_repr(c):
+        if isinstance(c,int):
+            return c
+        else:
+            return ord(c)
+
+    return u''.join('\\x{:x}'.format(backslashreplace_repr(c)) for c in s[start:end]),end
+
+
+def get_decode_str(s):
+    try:
+        return s.decode('utf-8', 'backslashreplace')
+    except:
+        codecs.register_error('backslashreplace_py2', backslashreplace_py2)
+        return s.decode('utf-8', 'backslashreplace_py2')
+
+
+def _get_st_home():
+    pypath = os.path.normpath(os.path.abspath(__file__))
+    d_utilities = dirname(dirname(pypath))
+
+    if os.path.basename(d_utilities).lower()=="utilities":
+        return dirname(d_utilities)
+    else:
+        _RaiseSystemException("failed to load Stata's shared library")
+
+
+def _get_executable_path():
+    sys_exec_path = sys.executable
+    if os.path.isfile(sys_exec_path):
+        return sys_exec_path
+
+    os_system = platform.system()
+    if os_system!="Windows":
+        sys_exec_path_non_windows = os.path.join(os.__file__.split('lib/')[0], 'bin', 'python')
+        if os.path.isfile(sys_exec_path_non_windows):
+            return sys_exec_path_non_windows
+
+    return sys_exec_path
+
+
+def _init_stata():
+    stlib.StataSO_Main.restype = c_int
+    stlib.StataSO_Main.argtypes = (c_int, POINTER(c_char_p))
+
+    libpath = ['-pyexec', _get_executable_path()]
+    sarr = (c_char_p * len(libpath))()
+    sarr[:] = [get_encode_str(s) for s in libpath]
+    
+    rc = stlib.StataSO_Main(2, sarr)
+
+    return(rc)
+
+
+def init(edition):
+    """
+    Initialize Stata's environment within Python.
+
+    Parameters
+    ----------
+    edition : str
+        The Stata edition to be used. It can be one of **mp**, **se**, or **be**.
+    """
+    global stinitialized
+    global sfiinitialized
+    global stlibpath
+    global stlib
+    global stedition
+    global stipython
+    if stinitialized is False:
+        st_home = _get_st_home()
+        os.environ['SYSDIR_STATA'] = st_home
+        lib_path = os.path.normpath(_get_lib_path(st_home, edition))
+        stlibpath = lib_path
+        stedition = _get_stata_edition(edition)
+
+        try:
+            stlib = cdll.LoadLibrary(lib_path)
+        except:
+            _RaiseSystemException("failed to load Stata's shared library")
+
+        if stlib is None:
+            _RaiseSystemException("failed to load Stata's shared library")		
+
+        sfiinitialized = True
+        rc = _init_stata()
+        msg = get_output()
+        if rc < 0:
+            if rc==-7100:
+                sfiinitialized = False
+            else:
+                _RaiseSystemException("failed to initialize Stata"+'\n'+msg)
+        else:
+            _print_greeting_message(msg)
+	
+        stinitialized = True
+        _load_system_config()
+
+        stipython = 0
+        try:
+            import pystata.ipython.stpymagic
+            if stipython == 0:
+                stipython = 5	    
+        except IPythonError:
+            pass 
+        except IPyKernelError:
+            pass
+        except:
+            stipython = 5
+
+        if sys.version_info[0] < 3:
+            reload(sys)
+            sys.setdefaultencoding('utf-8')
+
+        _check_duplicate_kmp(edition)
+
+
+def check_initialized():
+    if stinitialized is False:
+        _RaiseSystemException('''
+    Note: Stata environment has not been initialized yet. 
+    To proceed, you must call init() function in the config module as follows:
+
+        from pystata import config
+        config.init()''')
+
+
+@atexit.register
+def shutdown():
+    global stlib
+    global stinitialized
+
+    if stinitialized:
+        try:
+            stlib.StataSO_Shutdown.restype = None
+            stlib.StataSO_Shutdown()
+        except:
+            raise
+
+
+def is_stata_initialized():
+    """
+    Check whether Stata has been initialized.
+
+    Returns
+    -------
+    bool
+        True if Stata has been successfully initialized.
+    """	
+    global stinitialized
+    return stinitialized
+
+
+def _get_python_version_str():
+    global pyversion
+    s = [str(i) for i in pyversion]
+    return ".".join(s)
+
+
+def _get_stata_version_str():
+    global stversion
+    global stedition
+    if stversion=='':
+        return stedition
+    else:
+        return 'Stata ' + stversion + ' (' + stedition + ')'
+
+
+def get_graph_size_str(info):
+    global stconfig
+    if info=='gw':
+        grwidth = stconfig['grwidth']
+        if grwidth[0]=='default':
+            return 'default'
+        else:
+            return str(grwidth[0])+grwidth[1]
+    else:
+        grheight = stconfig['grheight']
+        if grheight[0]=='default':
+            return 'default'
+        else:
+            return str(grheight[0])+grheight[1]
+
+
+def status():
+    """
+    Display current system information and settings.
+    """
+    if stinitialized is False:
+        print('Stata environment has not been initialized yet')
+    else:
+        print('    System information')
+        print('      Python version         %s' % _get_python_version_str())
+        print('      Stata version          %s' % _get_stata_version_str())
+        print('      Stata library path     %s' % stlibpath)
+        print('      Stata initialized      %s' % str(stinitialized))
+        print('      sfi initialized        %s\n' % str(sfiinitialized))
+        print('    Settings')
+        print('      graphic display       ', stconfig['grshow'])  
+        print('      graphic size          ', ' width = ', get_graph_size_str('gw'), ', height = ', get_graph_size_str('gh'), sep='')
+        print('      graphic format        ', stconfig['grformat'])
+
+
+def get_output():
+    stlib.StataSO_GetOutputBuffer.restype = c_char_p
+    foo = stlib.StataSO_GetOutputBuffer()
+
+    mystr = get_decode_str(c_char_p(foo).value)
+    return mystr
+
+
+def get_stipython():
+    global stipython
+    return stipython
+
+
+def set_graph_format(gformat, perm=False):
+    """
+    Set the file format used to export and display graphs. By default, 
+    graphs generated by Stata are exported and displayed as SVG files.
+
+    The supported formats are **svg**, **png**, and **pdf**. If **svg** or 
+    **png** is specified, the graph is embedded. If **pdf** is specified, the 
+    graph is exported to a PDF file in the current working directory with a 
+    numeric name, such as 0.pdf, 1.pdf, 2.pdf, etc. This is useful when you 
+    try to export a notebook to a PDF via LaTex and you want the graph to be 
+    embedded.	
+
+    Parameters
+    ----------
+    gformat : str
+        The graph format. It can be **svg**, **png**, or **pdf**.
+
+    perm  : bool, optional 
+        When set to True, in addition to making the change right now, 
+        the setting will be remembered and become the default 
+        setting when you invoke Stata. Default is False.
+    """
+    global stconfig 
+
+    if perm is not True and perm is not False:
+        raise ValueError("perm must be a boolean value") 
+
+    if gformat=='svg':	
+        stconfig['grformat'] = 'svg'
+    elif gformat=="png":
+        stconfig['grformat'] = 'png'
+    elif gformat=='pdf':
+        stconfig['grformat'] = 'pdf'
+    else:
+        raise ValueError("invalid graph format")
+
+    if perm:
+        _save_system_config("grformat", stconfig['grformat'])
+
+
+def _get_figure_size_info(ustr):
+    finfo = []
+    ustr = ustr.strip()
+    if ustr.lower() == 'default':
+        finfo.append('default')
+        finfo.append('in')
+    else:
+        try:
+            figsize = round(float(ustr))
+            finfo.append(figsize)
+            finfo.append('in')		
+        except ValueError:
+            if ustr[-2:] == 'px':
+                figsize = ustr[:-2].strip()
+                if figsize.lower()!='default':
+                    try:
+                        figsize =  int(round(float(figsize)))
+                    except ValueError:
+                        figsize = -1
+
+                finfo.append(figsize)
+                finfo.append('px')
+            elif ustr[-2:] == 'in':
+                figsize = ustr[:-2].strip()
+                if figsize.lower()!='default':
+                    try:
+                        figsize =  float(figsize)
+                    except ValueError:
+                        figsize = -1
+
+                finfo.append(figsize)
+                finfo.append('in')
+            elif ustr[-2:] == 'cm':
+                figsize = ustr[:-2].strip()
+                if figsize.lower()!='default':
+                    try:
+                        figsize =  float(figsize)
+                    except ValueError:
+                        figsize = -1
+
+                    finfo.append(round(figsize, 3))
+                else:
+                    finfo.append(figsize)
+
+                finfo.append('cm')         
+            else:
+                finfo.append(-1)
+                finfo.append('in')
+
+    return finfo
+
+
+def _add_java_home_to_path():
+    os_system = platform.system()
+    if os_system=="Windows":
+        import sfi
+        javahome = sfi.Macro.getGlobal('c(java_home)')
+        if javahome!='':
+            javahome = os.path.join(javahome, 'bin')
+            ospath = os.environ['PATH']
+
+            if ospath not in ospath.split(';'):
+                os.environ['PATH'] = os.environ.get('PATH') + ";" + javahome
+
+
+def _load_system_config():
+    if sfiinitialized:
+        try:
+            import sfi 
+            grwidth_pref = sfi.Preference.getSavedPref('pystata', 'grwidth', '')
+            grheight_pref = sfi.Preference.getSavedPref('pystata', 'grheight', '')
+
+            if grwidth_pref!="" and grheight_pref!="":
+                set_graph_size(width=grwidth_pref, height=grheight_pref)
+            elif grwidth_pref!="":
+                set_graph_size(width=grwidth_pref)
+            elif grheight_pref!="":
+                set_graph_size(height=grheight_pref)
+
+            grformat_pref = sfi.Preference.getSavedPref('pystata', 'grformat', '')
+            if grformat_pref!="":
+                set_graph_format(gformat=grformat_pref)
+
+            grshow_pref = sfi.Preference.getSavedPref('pystata', 'grshow', '')
+            if grshow_pref!="":
+                if grshow_pref=="1":
+                    set_graph_show(show=True)
+                else:
+                    set_graph_show(show=False)
+
+            streamout_pref = sfi.Preference.getSavedPref('pystata', 'streamout', '')
+            if streamout_pref!="":
+                if streamout_pref=="on":
+                    set_streaming_output_mode(flag='on')
+                else:
+                    set_streaming_output_mode(flag='off')
+
+            global stversion
+            stversion = str(sfi.Scalar.getValue('c(stata_version)'))
+	    
+            _add_java_home_to_path()
+        except:
+            print('''
+Warning: failed to load the system default configuration. The following 
+settings will be applied:
+            ''')
+            status()
+
+
+def _save_system_config(key, value):
+    if sfiinitialized:
+        try:
+            import sfi 
+            sfi.Preference.setSavedPref("pystata", key, value)		
+        except:
+            _RaiseSystemException("failed to store the specified setting") 
+
+
+def set_graph_size(width=None, height=None, perm=False):
+    """
+    Set the graph size for images to be exported and displayed. By default, 
+    the graphs generated by Stata are exported using a dimension of 5.5 inches 
+    for the width by 4 inches for the height. Either the width or height must 
+    be specified, and both may be specified. If only one is specified, the 
+    other one is calculated from the aspect ratio.  
+
+    The width or height can be specified as a floating-point number, a string 
+    with a floating-point number and its unit, or **default**. The supported 
+    units are inches (**in**), pixels (**px**), or centimeters (**cm**). If 
+    no unit is specified, **in** is assumed. For example, **width = 3** sets 
+    the width to 3 inches, which is the same as specifying **width = 3in**. 
+    And **width = 300px** sets the width to 300 pixels.
+
+    Parameters
+    ----------
+    width : float or str
+        The graph width.
+
+    height: float or str
+        The graph height.
+
+    perm  : bool, optional 
+        When set to True, in addition to making the change right now, 
+        the setting will be remembered and become the default 
+        setting when you invoke Stata. Default is False.
+    """
+    if width is None and height is None:
+        raise ValueError('one of width and height must be specified')
+
+    if perm is not True and perm is not False:
+        raise ValueError("perm must be a boolean value")
+
+    if width:
+        gwidth = _get_figure_size_info(str(width))
+        if gwidth[0] != 'default' and gwidth[0] < 0:
+            raise ValueError('graph width is invalid')
+	
+        gr_width = gwidth[0]
+        gr_width_unit = gwidth[1]
+    else:
+        gr_width = 'default'
+        gr_width_unit = 'in'
+
+    if height:
+        gheight = _get_figure_size_info(str(height))
+        if gheight[0] != 'default' and gheight[0] < 0:
+            raise ValueError('graph height is invalid')
+
+        gr_height = gheight[0]
+        gr_height_unit = gheight[1]
+    else:
+        gr_height = 'default'
+        gr_height_unit = 'in'
+
+    global stconfig
+    grwidth = []
+    grheight = []
+    if width and height:
+        grwidth.append(gr_width)
+        grwidth.append(gr_width_unit)
+        grheight.append(gr_height)
+        grheight.append(gr_height_unit)
+    elif width:
+        grwidth.append(gr_width)
+        grwidth.append(gr_width_unit)
+        grheight.append('default')
+        grheight.append(gr_width_unit)
+    elif height:
+        grwidth.append('default')
+        grwidth.append(gr_height_unit)
+        grheight.append(gr_height)
+        grheight.append(gr_height_unit)
+    else:
+        grwidth.append(gr_width)
+        grwidth.append(gr_width_unit)
+        grheight.append(gr_height)
+        grheight.append(gr_height_unit)
+
+    stconfig['grwidth'] = grwidth
+    stconfig['grheight'] = grheight
+
+    if perm:
+        _save_system_config("grwidth", str(grwidth[0])+grwidth[1])
+        _save_system_config("grheight", str(grheight[0])+grheight[1])
+
+
+def set_graph_show(show, perm=False):
+    """
+    Set whether the graphs generated by Stata are to be exported and 
+    displayed. By default, the graphs are exported and displayed 
+    in the output. If `show` is set to False, graphs will not be 
+    exported and displayed. 
+
+    Parameters
+    ----------
+    show : bool
+        Export and display Stata-generated graphs in the output.
+
+    perm  : bool, optional 
+        When set to True, in addition to making the change right now, 
+        the setting will be remembered and become the default 
+        setting when you invoke Stata. Default is False.
+    """
+    global stconfig
+
+    if perm is not True and perm is not False:
+        raise ValueError("perm must be a boolean value") 
+
+    if show is True:	
+        stconfig['grshow'] = True
+    elif show is False:
+        stconfig['grshow'] = False
+    else:
+        raise TypeError("show must be a boolean value") 
+
+    if perm:
+        if show:
+            _save_system_config("grshow", "1")
+        else:
+            _save_system_config("grshow", "0")
+
+
+def set_streaming_output_mode(flag, perm=False):
+    global stconfig
+
+    if perm is not True and perm is not False:
+        raise ValueError("perm must be a boolean value") 
+
+    if flag == "on":
+        stconfig['streamout'] = 'on'
+    elif flag == "off":
+        stconfig['streamout'] = 'off'
+    else:
+        raise ValueError("The value for output mode must be either on or off. Default is on.")
+
+    if perm:
+        _save_system_config("streamout", stconfig['streamout'])
+
+
+def set_output_file(filename, replace=False):
+    """
+    Write Stata output to a text file. By default, Stata output is printed on
+    the screen. The file extension may be **.txt** or **.log**. You must 
+    supply a file extension if you want one because none is assumed.
+
+    Parameters
+    ----------
+    filename : str
+        Name of the text file.
+
+    replace : bool, optional 
+        Replace the output file if it exists. Default is False.
+    """
+    global pyversion
+    global stoutputf
+    
+    if os.path.isfile(filename):
+        if not replace:
+            raise OSError(filename + ' already exists')
+
+        os.remove(filename)
+
+    if pyversion[0] < 3:
+        f = open(filename, 'ab')
+    else:
+        f = open(filename, 'a', newline='\n', encoding='utf-8')
+
+    stoutputf = f
+
+
+def close_output_file():
+    """
+    Stop writing Stata output to a text file. This function should be used 
+    after having used :meth:`~pystata.config.set_output_file`. If it returns 
+    without an error, any Stata output that follows will instead be printed 
+    on the screen.
+    """
+    global stoutputf
+    if stoutputf is not None:
+        stoutputf.close()
+

pystata/core/__init__.py

@@ -0,0 +1,3 @@
+from pystata.config import check_initialized
+
+check_initialized()

pystata/core/numpy2mata.py

@@ -0,0 +1,53 @@
+import sfi
+import numpy as np
+
+def array_from_mata(mat):
+    return np.array(sfi.Mata.get(mat))
+
+
+def array_to_mata(arr, mat):
+    if not isinstance(arr, np.ndarray):
+        raise TypeError("An NumPy array is required.")
+
+    ndim = len(arr.shape)
+    if ndim < 1 or ndim >= 3:
+        raise TypeError("Dimension of array must not be greater than 2.")
+
+    nobs = len(arr)
+    if nobs == 0:
+        return None
+
+    dtype = arr.dtype.name
+    if dtype in ['bool_', 'bool8', 'byte']:
+        dtypestr = 'real'
+    elif dtype in ['short', 'intc', 'int8', 'int16', 'int32', 'ubyte', 'ushort', 'uintc', 'uint8', 'uint16']:
+        dtypestr = 'real'
+    elif dtype in ['int_', 'longlong', 'intp', 'int64', 'uint', 'ulonglong', 'uint32', 'uint64']:
+        dtypestr = 'real'
+    elif dtype in ['half', 'single', 'float16', 'float32']:
+        dtypestr = 'real'
+    elif dtype in ['double', 'float_', 'longfloat', 'float64', 'float96', 'float128']:
+        dtypestr = 'real'
+    elif dtype in ['csingle', 'cdouble', 'clongdouble', 'complex64', 'complex128', 'complex_']:
+        dtypestr = 'complex'
+    else:
+        dtypestr = 'string'
+
+    if ndim == 1:
+        if dtypestr=='real':
+            sfi.Mata.create(mat, 1, arr.shape[0], sfi.Missing.getValue())
+        elif dtypestr=='complex':
+            sfi.Mata.create(mat, 1, arr.shape[0], 0j)
+        else:
+            sfi.Mata.create(mat, 1, arr.shape[0], '')
+
+        sfi.Mata.store(mat, arr)
+    else:
+        if dtypestr=='real':
+            sfi.Mata.create(mat, arr.shape[0], arr.shape[1], sfi.Missing.getValue())
+        elif dtypestr=='complex':
+            sfi.Mata.create(mat, arr.shape[0], arr.shape[1], 0j)
+        else:
+            sfi.Mata.create(mat, arr.shape[0], arr.shape[1], '')
+
+        sfi.Mata.store(mat, arr)

pystata/core/numpy2stata.py

@@ -0,0 +1,112 @@
+import sfi
+import numpy as np
+
+def _get_varname(arr):
+    return [str(e) for e in arr]
+
+
+def _add_var(name, type, stfr=None):
+    if stfr is None:
+        if type=="byte":
+            sfi.Data.addVarByte(name)
+        elif type=="int":
+            sfi.Data.addVarInt(name)
+        elif type=="long":
+            sfi.Data.addVarLong(name)
+        elif type=="float":
+            sfi.Data.addVarFloat(name)
+        elif type=="double":
+            sfi.Data.addVarDouble(name)
+        else:
+            sfi.Data.addVarStr(name, 9)
+    else:
+        if type=="byte":
+            stfr.addVarByte(name)
+        elif type=="int":
+            stfr.addVarInt(name)
+        elif type=="long":
+            stfr.addVarLong(name)
+        elif type=="float":
+            stfr.addVarFloat(name)
+        elif type=="double":
+            stfr.addVarDouble(name)
+        else:
+            stfr.addVarStr(name, 9)
+
+
+def array_to_stata(arr, stfr, prefix):
+    if not isinstance(arr, np.ndarray):
+        raise TypeError("An NumPy array is required.")
+
+    ndim = len(arr.shape)
+    if ndim < 1 or ndim >= 3:
+        raise TypeError("Dimension of array must not be greater than 2.")
+
+    nobs = len(arr)
+    if nobs == 0:
+        return None
+
+    vtype = arr.dtype.name
+    if vtype in ['bool_', 'bool8', 'byte']:
+        vtypestr = 'byte'
+    elif vtype in ['short', 'intc', 'int8', 'int16', 'int32', 'ubyte', 'ushort', 'uintc', 'uint8', 'uint16']:
+        vtypestr = 'int'
+    elif vtype in ['int_', 'longlong', 'intp', 'int64', 'uint', 'ulonglong', 'uint32', 'uint64']:
+        vtypestr = 'long'
+    elif vtype in ['half', 'single', 'float16', 'float32']:
+        vtypestr = 'float'
+    elif vtype in ['double', 'float_', 'longfloat', 'float64', 'float96', 'float128']:
+        vtypestr = 'double'
+    else:
+        vtypestr = 'str'
+
+    if stfr is None:
+        sfi.Data.setObsTotal(nobs)
+        if ndim == 1:
+            _add_var(prefix+"1", vtypestr)
+            sfi.Data.store(0, None, arr)	
+        else:
+            ncol = arr.shape[1]
+            for col in range(ncol):
+                _add_var(prefix+str(col+1), vtypestr)
+                dta = arr[:,col]
+                sfi.Data.store(col, None, dta)
+    else:
+        fr = sfi.Frame.create(stfr)
+        fr.setObsTotal(nobs)
+
+        if ndim == 1:
+            _add_var(prefix+"1", vtypestr, fr)
+            fr.store(0, None, arr)	
+        else:
+            ncol = arr.shape[1]
+            for col in range(ncol):
+                _add_var(prefix+str(col+1), vtypestr, fr)
+                dta = arr[:,col]
+                fr.store(col, None, dta)
+
+
+def array_from_stata(stfr, var, obs, selectvar, valuelabel, missingval):
+    if stfr is None:
+        nobs = sfi.Data.getObsTotal()
+        if nobs <= 0:
+            return None
+
+        if missingval is None:
+            return(np.array(sfi.Data.get(var, obs, selectvar, valuelabel)))
+        else:
+            return(np.array(sfi.Data.get(var, obs, selectvar, valuelabel, missingval)))
+    else:
+        fr = sfi.Frame.connect(stfr)
+        nobs = fr.getObsTotal()
+        if nobs <= 0:
+            return None
+
+        if missingval is None:
+            return(np.array(fr.get(var, obs, selectvar, valuelabel)))
+        else:
+            return(np.array(fr.get(var, obs, selectvar, valuelabel, missingval)))
+
+
+def array_from_matrix(stmat):
+    return np.array(stmat)

pystata/core/pandas2stata.py

@@ -0,0 +1,156 @@
+import sfi
+import pandas as pd
+
+def _make_indexed_name(index, stnames, pdnames):
+    count = 0
+    varn = "v" + str(index+count)
+    while True:
+        if varn in stnames or varn in pdnames:
+            count = count + 1
+            varn = "v" + str(index+count)
+        else:
+            break
+
+    return varn 
+
+
+def _make_varname(s, index, stnames, pdnames):
+    s = str(s)
+    if sfi.SFIToolkit.isValidVariableName(s):
+        stnames.append(s)
+        return(s)
+    else:
+        try:
+            varn = sfi.SFIToolkit.makeVarName(s, True)
+            if varn in stnames or varn in pdnames:
+                varn = _make_indexed_name(index, stnames, pdnames)
+        except:
+            varn = _make_indexed_name(index, stnames, pdnames)
+
+        stnames.append(varn)	
+        return varn
+
+
+def _add_var(name, type, stfr=None):
+    if stfr is None:
+        if type=="byte":
+            sfi.Data.addVarByte(name)
+        elif type=="int":
+            sfi.Data.addVarInt(name)
+        elif type=="long":
+            sfi.Data.addVarLong(name)
+        elif type=="float":
+            sfi.Data.addVarFloat(name)
+        elif type=="double":
+            sfi.Data.addVarDouble(name)
+        else:
+            sfi.Data.addVarStr(name, 9)
+    else:
+        if type=="byte":
+            stfr.addVarByte(name)
+        elif type=="int":
+            stfr.addVarInt(name)
+        elif type=="long":
+            stfr.addVarLong(name)
+        elif type=="float":
+            stfr.addVarFloat(name)
+        elif type=="double":
+            stfr.addVarDouble(name)
+        else:
+            stfr.addVarStr(name, 9)
+
+
+def dataframe_to_stata(df, stfr):
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError("A Pandas dataframe is required.")
+
+    nobs = len(df)
+    if nobs == 0:
+        return None
+
+    colnames = list(df.columns)
+    stnames = []
+
+    if stfr is None:
+        sfi.Data.setObsTotal(nobs)
+        var = 0
+        for col in colnames:
+            vtype = df.dtypes[col].name
+            dta = df[col]
+            col = _make_varname(col, var+1, stnames, colnames)
+            if vtype=="int_" or vtype=="int8" or vtype=="int16" or vtype=="int32" or \
+                vtype=="uint8" or vtype=="uint16":
+                _add_var(col, "int")
+                sfi.Data.store(var, None, dta)
+            elif vtype=="int64" or vtype=='uint32':
+                _add_var(col, "long")
+                sfi.Data.store(var, None, dta)
+            elif vtype=="float_" or vtype=="float16" or vtype=="float32":
+                _add_var(col, "float")
+                sfi.Data.store(var, None, dta)
+            elif vtype=="float64":
+                _add_var(col, "double")
+                sfi.Data.store(var, None, dta)
+            elif vtype=="bool":
+                _add_var(col, "byte")
+                sfi.Data.store(var, None, dta)
+            else:
+                _add_var(col, "str")
+                sfi.Data.store(var, None, dta.astype(str))
+
+            var = var + 1
+    else:
+        fr = sfi.Frame.create(stfr)
+        fr.setObsTotal(nobs)
+        var = 0
+        for col in colnames:
+            vtype = df.dtypes[col].name
+            dta = df[col]
+            col = _make_varname(col, var+1, stnames, colnames)
+            if vtype=="int_" or vtype=="int8" or vtype=="int16" or vtype=="int32" or \
+                vtype=="uint8" or vtype=="uint16":
+                _add_var(col, "int", fr)
+                fr.store(var, None, dta)
+            elif vtype=="int64" or vtype=='uint32':
+                _add_var(col, "long", fr)
+                fr.store(var, None, dta)
+            elif vtype=="float_" or vtype=="float16" or vtype=="float32":
+                _add_var(col, "float", fr)
+                fr.store(var, None, dta)
+            elif vtype=="float64":
+                _add_var(col, "double", fr)
+                fr.store(var, None, dta)
+            elif vtype=="bool":
+                _add_var(col, "byte", fr)
+                fr.store(var, None, dta)
+            else:
+                _add_var(col, "str", fr)
+                fr.store(var, None, dta.astype(str))
+
+            var = var + 1
+
+
+def dataframe_from_stata(stfr, var, obs, selectvar, valuelabel, missingval):
+    if stfr is None:
+        nobs = sfi.Data.getObsTotal()
+        if nobs <= 0:
+            return None
+
+        if missingval is None:
+            df = pd.DataFrame(sfi.Data.getAsDict(var, obs, selectvar, valuelabel))
+        else:
+            df = pd.DataFrame(sfi.Data.getAsDict(var, obs, selectvar, valuelabel, missingval))
+
+        return(df)
+    else:
+        fr = sfi.Frame.connect(stfr)
+        nobs = fr.getObsTotal()
+        if nobs <= 0:
+            return None
+
+        if missingval is None:
+            df = pd.DataFrame(fr.getAsDict(var, obs, selectvar, valuelabel))
+        else:
+            df = pd.DataFrame(fr.getAsDict(var, obs, selectvar, valuelabel, missingval))
+
+        return(df)

pystata/core/stout.py

@@ -0,0 +1,180 @@
+from __future__ import print_function
+from __future__ import unicode_literals
+from pystata import config
+import sys
+import threading 
+import time
+
+def output_get_interactive_result(output, real_cmd, colon, mode):
+    try:
+        if mode==2:
+            if colon:
+                fmt_str1 = ". mata:\n"
+            else:
+                fmt_str1 = ". mata\n"
+        else:
+            if colon:
+                fmt_str1 = ". python:\n"
+            else:
+                fmt_str1 = ". python\n"
+		
+        pos1 = output.index(fmt_str1)
+        pos1 = pos1 + len(fmt_str1)
+    except:
+        pos1 = 0
+
+    output = output[pos1:]
+
+    try:
+        if mode==2:
+            fmt_str2 = "-"*49 + " mata (type end to exit) "
+        else:
+            fmt_str2 = "-"*47 + " python (type end to exit) "
+
+        pos2 = output.index(fmt_str2)
+        pos2 = output.index("\n") + 1
+    except:
+        pos2 = 0
+
+    output = output[pos2:]
+
+    try:
+        fmt_str3 = real_cmd
+        pos3 = output.index(fmt_str3)
+        if pos3 != 0:
+            pos3 = 0
+        else:
+            pos3 = pos3 + len(fmt_str3)
+    except:
+        pos3 = 0
+
+    output = output[pos3:]
+
+    try:
+        if mode==2:
+            fmt_str4 = ": end\n"
+        else:
+            fmt_str4 = ">>> end\n"
+        pos4 = output.rindex(fmt_str4)
+    except:
+        pos4 = 0
+
+    return output[:pos4]
+
+
+class StataDisplay:
+    def write(self, text):
+        textList = text.split("\n")
+        for t in textList[:-1]:
+            config.stlib.StataSO_AppendOutputBuffer(config.get_encode_str(t))
+            config.stlib.StataSO_AppendOutputBuffer(config.get_encode_str("\n"))
+        config.stlib.StataSO_AppendOutputBuffer(config.get_encode_str(textList[-1]))
+
+    def flush(self):
+        pass
+
+
+class StataError:
+    def write(self, text):
+        config.stlib.StataSO_AppendOutputBuffer(config.get_encode_str(text))
+
+    def flush(self):
+        pass
+
+	
+class RedirectOutput:
+    """context manager for redirecting stdout/err"""
+
+    def __init__(self, stdout='', stderr=''):
+        self.stdout = stdout
+        self.stderr = stderr
+
+    def __enter__(self):
+        self.sys_stdout = sys.stdout
+        self.sys_stderr = sys.stderr
+
+        if self.stdout:
+            sys.stdout = self.stdout
+        if self.stderr:
+            if self.stderr == self.stdout:
+                sys.stderr = sys.stdout
+            else:
+                sys.stderr = self.stderr
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout = self.sys_stdout
+        sys.stderr = self.sys_stderr
+
+def _print_streaming_output(output, newline):
+    if config.pyversion[0] >= 3:
+        if newline:
+            print(output, flush=True, file=config.stoutputf)
+        else:
+            print(output, end='', flush=True, file=config.stoutputf)
+    else:
+        if newline:
+            print(config.get_encode_str(output), file=config.stoutputf)
+        else:
+            print(config.get_encode_str(output), end='', file=config.stoutputf)
+
+        sys.stdout.flush()
+
+
+class RepeatTimer(threading.Thread):
+    def __init__(self, tname, otype, queue, interval, real_cmd, colon, mode):       
+        threading.Thread.__init__(self, name=tname)
+        self.q = queue
+        self.otype = otype
+        self.interval = interval
+        self.is_done = False
+        self.old_stdout = sys.stdout
+        self.old_stderr = sys.stderr
+        self.real_cmd = real_cmd
+        self.colon = colon
+        self.mode = mode
+
+    def done(self):
+        sys.stdout = self.old_stdout
+        sys.stderr = self.old_stderr
+        self.is_done = True
+
+    def run(self):       
+        while not self.is_done:
+            self.sys_stdout = sys.stdout
+            self.sys_stderr = sys.stderr
+            sys.stdout = self.old_stdout
+            sys.stderr = self.old_stderr
+            output = config.get_output()
+            if self.q.empty():
+                if len(output)!=0:
+                    if self.mode!=1 and self.otype==2:
+                        output = output_get_interactive_result(output, self.real_cmd, self.colon, self.mode)
+                    
+                    _print_streaming_output(output, False)
+            else:
+                rc = self.q.get()
+                self.done()
+                if rc == 0:
+                    if self.otype==1:
+                        if len(output)!=0:
+                            _print_streaming_output(output, False)    
+                    else:
+                        if self.mode!=1:
+                            output = output_get_interactive_result(output, self.real_cmd, self.colon, self.mode)
+                            _print_streaming_output(output, False)
+                        else:
+                            _print_streaming_output(output, True)
+                else:
+                    if self.otype==1:
+                        raise SystemError(output)
+                    else:
+                        if rc!=3000:
+                            if self.mode!=1:
+                                output = output_get_interactive_result(output, self.real_cmd, self.colon, self.mode)
+                                _print_streaming_output(output, False)
+                            else:
+                                raise SystemError(output)
+
+            sys.stdout = self.sys_stdout
+            sys.stderr = self.sys_stderr
+            time.sleep(self.interval)

pystata/ipython/__init__.py

@@ -0,0 +1,5 @@
+from pystata.config import check_initialized
+
+check_initialized()				
+
+from . import stpymagic

pystata/ipython/grdisplay.py

@@ -0,0 +1,164 @@
+from pystata.config import stlib, stconfig, get_encode_str
+from IPython.display import SVG, display, Image
+from pystata.ipython.ipy_utils import get_ipython_stata_cache_dir
+import sfi
+import os
+
+pdf_counter = 0
+
+def _get_graphs_info():
+    stlib.StataSO_Execute(get_encode_str("qui _gr_list list"), False)
+    gnamelist = sfi.Macro.getGlobal("r(_grlist)")
+
+    graphs_info = []
+    for gname in gnamelist.split():
+        graphs_info.append(gname)
+
+    return graphs_info
+
+
+class _Pdf_Display_Obj:
+    def __init__(self, pdf, width, height):
+        self.pdf = pdf
+        self.width = width
+        self.height = height
+
+    def _repr_html_(self):
+        return '<iframe src={0} width={1} height={2} frameBorder="0"></iframe>'.format(self.pdf, self.width, self.height)
+
+    def _repr_latex_(self):
+        return r'\includegraphics[width=1.0\textwidth,keepaspectratio]{{{0}}}'.format(self.pdf)
+
+    def __repr__(self):
+        return '(file ' + self.pdf + ' written in PDF format)'
+
+
+def display_stata_graph():
+    global pdf_counter
+
+    grformat = stconfig['grformat']
+    grwidth = stconfig['grwidth']
+    grheight = stconfig['grheight']
+    if grformat=="svg":
+        if grwidth[0]=='default':
+            gwidth_str = ""
+        else:
+            if grwidth[1]=='cm':
+                gwidth_str = str(round(grwidth[0]/2.54, 3)) + 'in'
+            else:
+                gwidth_str = str(grwidth[0]) + grwidth[1]
+
+        if grheight[0]=='default':
+            gheight_str = ""
+        else:
+            if grheight[1]=='cm':
+                gheight_str = str(round(grheight[0]/2.54, 3)) + 'in'
+            else:	    
+                gheight_str = str(grheight[0]) + grheight[1]
+    elif grformat=="png":
+        if grwidth[0]=='default':
+            gwidth_str = ""
+        else:	    
+            if grwidth[1]=='px':
+                gwidth_str = str(grwidth[0])
+            elif grwidth[1]=='cm':
+                gwidth_str = str(int(round(grwidth[0]*96/2.54)))
+            else:
+                gwidth_str = str(int(round(grwidth[0]*96)))
+
+        if grheight[0]=='default':
+            gheight_str = ""
+        else:
+            if grheight[1]=='px':
+                gheight_str = str(grheight[0])
+            elif grheight[1]=='cm':
+                gheight_str = str(int(round(grheight[0]*96/2.54)))
+            else:
+                gheight_str = str(int(round(grheight[0]*96)))
+    else:
+        gwidth = -1
+        gheight = -1
+        if grwidth[0]=='default':
+            gwidth_str = ""
+        else:	 
+            if grwidth[1]=='px':
+                gwidth_str = str(grwidth[0]*1.0/96)
+                gwidth = grwidth[0]
+            elif grwidth[1]=='cm':
+                gwidth_str = str(grwidth[0]*1.0/2.54)
+                gwidth = grwidth[0]*96/2.54               
+            else:
+                gwidth_str = str(grwidth[0])
+                gwidth = grwidth[0]*96
+
+        if grheight[0]=='default':
+            gheight_str = ""
+        else:
+            if grheight[1]=='px':
+                gheight_str = str(grheight[0]*1.0/96)
+                gheight = grheight[0]
+            elif grheight[1]=='cm':
+                gheight_str = str(grheight[0]*1.0/2.54)
+                gheight = grheight[0]*96/2.54
+            else:
+                gheight_str = str(grheight[0])
+                gheight = grheight[0]*96
+
+        if gwidth==-1 and gheight==-1:
+            gwidth = 528
+            gheight = 384
+        elif gwidth==-1:
+            gwidth = gheight*528.0/384
+        elif gheight==-1:
+            gheight = gwidth*384.0/528
+
+    graphs_info = _get_graphs_info()
+    gdir = get_ipython_stata_cache_dir()
+    glen = len(graphs_info)
+    if glen > 0:
+        for i in range(glen):
+            gph_disp = 'qui graph display %s' % graphs_info[i]
+            rc = stlib.StataSO_Execute(get_encode_str(gph_disp), False)
+            if rc!=0:
+                continue
+
+            if grformat=='svg':
+                graph_out = os.path.join(gdir, 'temp_graph'+str(i)+'.svg')
+                if gwidth_str!="" and gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace width(%s) height(%s) ' % (graph_out, graphs_info[i], gwidth_str, gheight_str)		
+                elif gwidth_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace width(%s) ' % (graph_out, graphs_info[i], gwidth_str)		
+                elif gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace height(%s) ' % (graph_out, graphs_info[i], gheight_str)
+                else:
+                    gph_exp = 'qui graph export "%s", name(%s) replace width(528) height(384)' % (graph_out, graphs_info[i])
+
+                stlib.StataSO_Execute(get_encode_str(gph_exp), False)
+                display(SVG(filename=graph_out))
+            elif grformat=='png':
+                graph_out = os.path.join(gdir, 'temp_graph'+str(i)+'.png')
+                if gwidth_str!="" and gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace width(%s) height(%s) ' % (graph_out, graphs_info[i], gwidth_str, gheight_str)
+                elif gwidth_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace width(%s) ' % (graph_out, graphs_info[i], gwidth_str)
+                elif gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace height(%s) ' % (graph_out, graphs_info[i], gheight_str)
+                else:
+                    gph_exp = 'qui graph export "%s", name(%s) replace ' % (graph_out, graphs_info[i])
+
+                stlib.StataSO_Execute(get_encode_str(gph_exp), False)
+                display(Image(filename=graph_out))
+            else:
+                graph_out = os.path.join(os.getcwd(), str(pdf_counter)+'.pdf')
+                if gwidth_str!="" and gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace xsize(%s) ysize(%s) ' % (graph_out, graphs_info[i], gwidth_str, gheight_str)
+                elif gwidth_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace xsize(%s) ' % (graph_out, graphs_info[i], gwidth_str)
+                elif gheight_str!="":
+                    gph_exp = 'qui graph export "%s", name(%s) replace ysize(%s) ' % (graph_out, graphs_info[i], gheight_str)
+                else:
+                    gph_exp = 'qui graph export "%s", name(%s) replace ' % (graph_out, graphs_info[i])
+
+                stlib.StataSO_Execute(get_encode_str(gph_exp), False)
+                display(_Pdf_Display_Obj(os.path.relpath(graph_out), int(gwidth*1.1), int(gheight*1.1)))
+                pdf_counter += 1

pystata/ipython/ipy_utils.py

@@ -0,0 +1,8 @@
+from IPython import version_info as ipy_version
+if ipy_version[0] < 4:
+    from IPython.utils.path import get_ipython_cache_dir
+else:
+    from IPython.paths import get_ipython_cache_dir
+
+def get_ipython_stata_cache_dir():
+    return get_ipython_cache_dir()

pystata/ipython/stpymagic.py

@@ -0,0 +1,619 @@
+from __future__ import absolute_import, print_function
+import os
+import shlex
+
+from pystata import config as _config
+from pystata.stexception import IPythonError, IPyKernelError
+
+try:
+    from IPython.core.magic import (Magics, magics_class, line_cell_magic, needs_local_scope, line_magic)
+    from pystata.ipython.ipy_utils import get_ipython_stata_cache_dir
+except ImportError:
+    _config.stipython = 1
+    raise IPythonError('failed to import IPython package')
+
+from pystata import stata as _stata
+
+if not _stata.has_num_pand['pknum']: 
+    _config.stipython = 3
+elif not _stata.has_num_pand['pkpand']:
+    _config.stipython = 4
+
+if _stata.has_num_pand['pknum']: 
+    import numpy as np
+
+if _stata.has_num_pand['pkpand']:
+    import pandas as pd
+    from pystata.core import numpy2mata as _mata
+
+from IPython import get_ipython
+
+
+def _parse_arguments(inopts, allowopts, magicname):
+    res = {}
+    errmsg = 'Type ' + magicname + ' to get more information.'
+
+    opts = shlex.split(inopts, posix=False)
+
+    olen = len(opts)
+    if olen==0:
+        return res
+
+    i = 0
+    while i < olen:
+        if opts[i][0]=='-' and ':' in opts[i]:
+            raise SyntaxError('option ' + opts[i] + ' not allowed. ' + errmsg)
+
+        if i==(olen-1):
+            if opts[i] in allowopts:
+                res[opts[i]] = ''
+                i += 1
+            else:
+                tmp = opts[i] + ':'
+                if tmp in allowopts:
+                    raise SyntaxError('A value is required for option ' + opts[i] + '. ' + errmsg)
+                else:
+                    raise SyntaxError('option ' + opts[i] + ' not allowed. ' + errmsg)
+        else:
+            if opts[i] in allowopts:
+                if opts[i+1][0] != '-':
+                    raise SyntaxError('option ' + opts[i] + ' misspecified. ' + errmsg)
+                else:
+                    res[opts[i]] = ''
+                    i += 1
+            else:
+                tmp = opts[i] + ':'
+                if tmp in allowopts:
+                    if opts[i+1][0] == '-':
+                        raise SyntaxError('option ' + opts[i] + ' misspecified. ' + errmsg)
+                    else:
+                        res[opts[i]] = opts[i+1]
+                        i += 2
+                else:
+                    raise SyntaxError('option ' + opts[i] + ' not allowed. ' + errmsg)				
+
+    return res
+
+
+def _get_input_type(o):
+    if _stata.has_num_pand['pknum']: 
+        if isinstance(o, np.ndarray):
+            return 1 
+        
+    if _stata.has_num_pand['pkpand']: 
+        if isinstance(o, pd.DataFrame):
+            return 2
+	    
+    return 0
+
+
+@magics_class
+class PyStataMagic(Magics):
+
+    def __init__(self, shell):
+        super(PyStataMagic, self).__init__(shell)
+        self._lib_dir = os.path.join(get_ipython_stata_cache_dir(), 'stata')
+        if not os.path.exists(self._lib_dir):
+            os.makedirs(self._lib_dir)
+
+    @needs_local_scope
+    @line_cell_magic
+    def stata(self, line, cell=None, local_ns=None):
+        '''
+        Execute one line or a block of Stata commands.
+
+        When the line magic command **%stata** is used, a one-line Stata 
+        command can be specified and executed, as it would be in Stata's 
+        Command window. When the cell magic command **%%stata** is used, a 
+        block of Stata commands can be specified and executed all at once. 
+        This is similar to executing a series of commands from a do-file.
+
+        Cell magic syntax:
+
+            %%stata [-d DATA] [-f DFLIST|ARRLIST] [-force]
+             [-doutd DATAFRAME] [-douta ARRAY] [-foutd FRAMELIST] [-fouta FRAMELIST]
+             [-ret DICTIONARY] [-eret DICTIONARY] [-sret DICTIONARY] [-qui] [-nogr]
+             [-gw WIDTH] [-gh HEIGHT]
+
+            Optional arguments:
+
+              -d DATA               Load a NumPy array or pandas dataframe 
+                                    into Stata as the current working dataset.
+
+              -f DFLIST|ARRLIST     Load one or multiple NumPy arrays or 
+                                    pandas dataframes into Stata as frames. 
+                                    The arrays and dataframes should be 
+                                    separated by commas. Each array or 
+                                    dataframe is stored in Stata as a separate 
+                                    frame with the same name.
+
+              -force                Force loading of the NumPy array or pandas 
+                                    dataframe into Stata as the current working 
+                                    dataset, even if the dataset in memory has 
+                                    changed since it was last saved; or force 
+                                    loading of the NumPy arrays or pandas dataframes 
+                                    into Stata as separate frames even if one or 
+                                    more of the frames already exist in Stata.
+
+              -doutd DATAFRAME      Save the dataset in memory as a pandas 
+                                    dataframe when the cell completes.
+
+              -douta ARRAY          Save the dataset in memory as a NumPy 
+                                    array when the cell completes.
+
+              -foutd FRAMELIST      Save one or multiple Stata frames as pandas 
+                                    dataframes when the cell completes. The Stata 
+                                    frames should be separated by commas. Each 
+                                    frame is stored in Python as a pandas 
+                                    dataframe. The variable names in each frame 
+                                    will be used as the column names in the 
+                                    corresponding dataframe. 
+
+              -fouta FRAMELIST      Save one or multiple Stata frames as NumPy 
+                                    arrays when the cell completes. The Stata frames 
+                                    should be separated by commas. Each frame is 
+                                    stored in Python as a NumPy array.
+
+              -ret DICTIONARY       Store current r() results into a dictionary.
+
+              -eret DICTIONARY      Store current e() results into a dictionary.
+ 
+              -sret DICTIONARY      Store current s() results into a dictionary.
+
+              -qui                  Run Stata commands but suppress output.
+
+              -nogr                 Do not display Stata graphics.
+
+              -gw WIDTH             Set graph width in inches, pixels, or centimeters; 
+                                    default is inches.
+
+              -gh HEIGHT            Set graph height in inches, pixels, or centimeters; 
+                                    default is inches.
+
+
+        Line magic syntax:
+
+            %stata stata_cmd
+        '''
+        if cell is None:
+            if not line:
+                raise SyntaxError("Stata command required")
+
+            _stata.run(line)
+            return
+
+        allowopts = ['-d:', '-f:', '-force', '-doutd:', '-douta:', '-foutd:', '-fouta:', '-ret:', '-eret:', '-sret:', '-qui', '-nogr', '-gw:', '-gh:']
+        args = _parse_arguments(line, allowopts, '%%stata?')
+
+        if local_ns is None:
+            local_ns = {}
+
+        force_to_load = False
+        if '-force' in args:
+            force_to_load = True
+
+        if '-d' in args:
+            if not _stata.has_num_pand['pknum'] and not _stata.has_num_pand['pkpand']:
+                raise SystemError('NumPy package or pandas package is required to use this argument.')
+
+            data = args['-d']
+            try:
+                val = local_ns[data]
+            except KeyError:
+                try:
+                    val = self.shell.user_ns[data]
+                except KeyError:
+                    raise NameError("name '%s' is not defined" % data)
+
+            
+            input_dtype = _get_input_type(val)
+            if input_dtype > 0:
+                try:
+                    if input_dtype==2:
+                        _stata.pdataframe_to_data(val, force=force_to_load)
+                    else:
+                        _stata.nparray_to_data(val, force=force_to_load)
+                except SystemError:
+                    raise
+                except:
+                    raise SystemError("Exception occurred. Data could not be loaded.")
+            else:
+                raise TypeError("A pandas dataframe or NumPy array is required.")
+
+        if '-f' in args:
+            if not _stata.has_num_pand['pknum'] and not _stata.has_num_pand['pkpand']:
+                raise SystemError('NumPy package or pandas package is required to use this argument.')
+
+            frames = args['-f'].replace("'", '').replace('"', '').split(',')
+            for fr in frames:
+                try:
+                    frval = local_ns[fr]
+                except KeyError:
+                    try:
+                        frval = self.shell.user_ns[fr]
+                    except KeyError:
+                        raise NameError("name '%s' is not defined" % fr)
+
+                input_ftype = _get_input_type(frval)
+                if input_ftype==0:
+                    raise TypeError("%s is not a pandas dataframe or NumPy array. Only dataframe or array is allowed." % fr)
+
+            for fr in frames:
+                try:
+                    frval = local_ns[fr]
+                except KeyError:
+                    frval = self.shell.user_ns[fr]
+
+                input_ftype = _get_input_type(frval)
+                try:
+                    if input_ftype==2:
+                        _stata.pdataframe_to_frame(frval, fr, force=force_to_load)
+                    else:
+                        _stata.nparray_to_frame(frval, fr, force=force_to_load)
+                except SystemError:
+                    raise
+                except:
+                    raise SystemError("Exception occurred. %s could not be loaded." % fr)
+
+
+        if '-gw' in args or '-gh' in args:
+            gwidth = _config.get_graph_size_str('gw')
+            gheight = _config.get_graph_size_str('gh')
+            if '-gw' in args and '-gh' in args:
+                _config.set_graph_size(args['-gw'], args['-gh'])
+            elif '-gw' in args:
+                _config.set_graph_size(args['-gw'], None)
+            else:
+                _config.set_graph_size(None, args['-gh'])
+
+        if '-nogr' in args:
+            grshow = _config.stconfig['grshow']
+            _config.set_graph_show(False)            
+
+        if '-qui' in args:
+            _stata.run(cell, quietly=True, inline=_config.stconfig['grshow'])
+        else:
+            _stata.run(cell, quietly=False, inline=_config.stconfig['grshow'])
+
+        if '-gw' in args or '-gh' in args:
+            _config.set_graph_size(gwidth, gheight)
+
+        if '-nogr' in args:
+            _config.set_graph_show(grshow)
+
+        if '-ret' in args or '-eret' in args or '-sret' in args:
+            if '-ret' in args:
+                val = _stata.get_return()
+                self.shell.push({args['-ret']: val })
+
+            if '-eret' in args:
+                val = _stata.get_ereturn()
+                self.shell.push({args['-eret']: val })
+
+            if '-sret' in args:
+                val = _stata.get_sreturn()
+                self.shell.push({args['-sret']: val })
+
+        if '-doutd' in args:
+            if not _stata.has_num_pand['pkpand']:
+                raise SystemError('pandas package is required to use this argument.')
+
+            try:
+                output_df = _stata.pdataframe_from_data()
+                self.shell.push({args['-doutd']: output_df })
+            except:
+                print("Exception occurred. Data could not be written to the dataframe.")
+
+        if '-douta' in args:
+            if not _stata.has_num_pand['pknum']:
+                raise SystemError('NumPy package is required to use this argument.')
+
+            try:
+                output_arr = _stata.nparray_from_data()
+                self.shell.push({args['-douta']: output_arr })
+            except:
+                print("Exception occurred. Data could not be written to the array.")
+
+        if '-foutd' in args:
+            if not _stata.has_num_pand['pkpand']:
+                raise SystemError('pandas package is required to use this argument.')
+
+            frames = args['-foutd'].replace("'", '').replace('"', '').split(',')
+            output_dfs = {}
+            for fr in frames:
+                try:
+                    output_df = _stata.pdataframe_from_frame(fr)
+                    output_dfs[fr] = output_df
+                except:
+                    raise SystemError("Exception occurred. Stata's frame %s could not be saved to a pandas dataframe." % fr)
+
+            self.shell.push(output_dfs)    
+
+        if '-fouta' in args:
+            if not _stata.has_num_pand['pknum']:
+                raise SystemError('NumPy package is required to use this argument.')
+
+            frames = args['-fouta'].replace("'", '').replace('"', '').split(',')
+            output_arrs = {}
+            for fr in frames:
+                try:
+                    output_arr = _stata.nparray_from_frame(fr)
+                    output_arrs[fr] = output_arr
+                except:
+                    raise SystemError("Exception occurred. Stata's frame %s could not be saved to a NumPy array." % fr)
+
+            self.shell.push(output_arrs)   
+
+
+    @needs_local_scope
+    @line_cell_magic
+    def mata(self, line, cell=None, local_ns=None):
+        '''
+        Execute one line or a block of Mata code.
+
+        When the **%mata** line magic command is used, one line of Mata code 
+        can be specified and executed. This is similar to specifying 
+        **mata: istmt** within Stata. When the **%%mata** cell magic command is 
+        used, a block of Mata code can be specified. The code is executed just 
+        as it would be in a do-file.
+
+        Cell magic syntax:
+
+            %%mata [-m ARRAYLIST] [-outm MATLIST] [-qui] [-c] 
+
+              Execute a block of Mata code. This is equivalent to running a 
+              block of Mata code within a do-file. You do not need to 
+              explicitly place the code within the mata[:] and end block. 
+			
+              Optional arguments:
+
+                -m ARRAYLIST      Load multiple NumPy arrays into Mata's 
+                                  interactive environment. The array names 
+                                  should be separated by commas. Each array is 
+                                  stored in Mata as a matrix with the same name.
+
+                -outm MATLIST     Save Mata matrices as NumPy arrays when the 
+                                  cell completes. The matrix names should be
+                                  separated by commas. Each matrix is stored 
+                                  in Python as a NumPy array.
+
+                -qui              Run Mata code but suppress output.
+
+                -c                This argument specifies that Mata code be 
+                                  executed in mata: mode. This means that
+                                  if Mata encounters an error, it will stop 
+                                  execution and return control to Python. The 
+                                  error will then be thrown as a Python SystemError 
+                                  exception.
+
+
+        Line magic syntax:
+
+            %mata [-c]
+			
+              Enter Mata's interactive environment. This is equivalent to 
+              typing mata or mata: in the Stata Command window.
+
+              Optional argument:
+
+                -c                Enter interactive Mata environment in mata:
+                                  mode. The default is to enter in mata mode.
+
+            %mata istmt 
+
+              Run a single-line Mata statement. This is equivalent to executing 
+              mata: istmt within Stata.
+        '''
+        if cell is None:
+            if not line:
+                stcmd = "mata"
+            elif line=='-c':
+                stcmd = 'mata:'
+            else:
+                stcmd = "mata: " + line
+
+            _stata.run(stcmd, inline=False)
+        else:
+            allowopts = ['-qui', '-c', '-m:', '-outm:']
+            args = _parse_arguments(line, allowopts, '%%mata?')
+
+            if local_ns is None:
+                local_ns = {}
+
+            if '-m' in args:
+                if not _stata.has_num_pand['pknum']:
+                    raise SystemError('NumPy package is required to use this argument.')
+		    
+                mats = args['-m'].replace("'", '').replace('"', '').split(',')
+                for m in mats:
+                    try:
+                        mval = local_ns[m]
+                    except KeyError:
+                        try:
+                            mval = self.shell.user_ns[m]
+                        except KeyError:
+                            raise NameError("name '%s' is not defined" % m)
+
+                for m in mats:
+                    try:
+                        mval = local_ns[m]
+                    except KeyError:
+                        mval = self.shell.user_ns[m]
+
+                    try:
+                        _mata.array_to_mata(mval, m)
+                    except:
+                        print("Exception occurred. Array %s could not be loaded." % m)
+
+
+            if cell[-1:] != '\n':
+                cell = cell + '\n'
+
+            if '-c' in args:
+                cell = "mata:\n" + cell + "end"
+            else:
+                cell = "mata\n" + cell + "end"
+
+            if '-qui' in args:
+                _stata.run(cell, quietly=True, inline=False)
+            else:
+                _stata.run(cell, inline=False)
+
+
+            if '-outm' in args:
+                if not _stata.has_num_pand['pknum']:
+                    raise SystemError('NumPy package is required to use this argument.')
+
+                mats = args['-outm'].replace("'", '').replace('"', '').split(',')
+                output_arrs = {}
+                for m in mats:
+                    try:
+                        output_arr = _mata.array_from_mata(m)
+                        output_arrs[m] = output_arr
+                    except:
+                        print("Exception occurred. Mata matrix %s could not be written to a NumPy array." % m)
+
+                self.shell.push(output_arrs)
+
+
+    @line_magic
+    def pystata(self, line):
+        '''
+        Stata utility commands.
+
+        Line magic syntax:
+
+            %pystata status
+
+              Display current system information and settings.
+
+
+            %pystata set graph_show True|False [, perm]
+
+              Set whether Stata graphics are displayed. The default is to 
+              display the graphics. Note that if multiple graphs are 
+              generated, only the last one is displayed. To display multiple
+              graphs, use the name() option with Stata's graph commands.
+
+
+            %pystata set graph_size w #[in|px|cm] [, perm]  
+            %pystata set graph_size h #[in|px|cm] [, perm]
+            %pystata set graph_size w #[in|px|cm] h #[in|px|cm] [, perm]
+
+              Set dimensions for Stata graphs. The default is a 5.5-inch width 
+              and 4-inch height. Values may be specified in inches, pixels, or 
+              centimeters; the default unit is inches. Either the width or height 
+              must be specified, or both. If only one is specified, the other one 
+              is determined by the aspect ratio.		  
+
+
+            %pystata set graph_format svg|png|pdf [, perm]
+
+              Set the graphic format used to display Stata graphs. The default 
+              is svg. If svg or png is specified, the graphs will be embedded. 
+              If pdf is specified, the graphs will be displayed, and exported 
+              to PDF files and stored in the current working directory with 
+              numeric names, such as 0.pdf, 1.pdf, 2.pdf, etc. Storing the PDF 
+              graph files in the current directory allows you to embed them in 
+              the notebook when exporting the notebook to a PDF via Latex.		  
+        '''
+        if line is None:
+            raise SyntaxError('subcommand required')
+
+        scmd = line.strip().split(',')
+        if len(scmd)>=3:
+            raise SyntaxError('invalid syntax')
+
+        sperm = False
+        sopt = scmd[1].strip() if len(scmd)==2 else ""
+        if sopt!="":
+            if sopt not in ["perm", "perma", "perman", "permane", "permanen", "permanent", "permanentl", "permanently"]:
+                raise SyntaxError('option ' + sopt + ' not allowed')
+            else:
+                sperm = True
+
+        scmd = scmd[0].strip().split()
+        slen = len(scmd)
+        if slen==0:
+            raise SyntaxError('subcommand required')
+
+        subcmd = scmd[0]
+        if subcmd=='help':
+            if slen!=1:
+                topic = ' '.join(scmd[1:])
+            else:
+                topic = 'help_advice'
+
+            _stata.run('help ' + topic, inline=False)
+        elif subcmd=='status':
+            if slen!=1:
+                raise SyntaxError(' '.join(scmd[1:]) + ' not allowed')
+            else:
+                _config.status()
+        elif subcmd=='set':
+            if slen==1:
+                raise SyntaxError('set type must be specified')
+
+            sset = scmd[1:]
+            settype = sset[0]
+            if settype=="graph_size":
+                if len(sset)!=3 and len(sset)!=5:
+                    raise ValueError('invalid graph_size set')
+
+                if len(sset)==3:
+                    if sset[1]=='width' or sset[1]=='w':
+                        _config.set_graph_size(width=sset[2], height=None, perm=sperm)
+                    elif sset[1]=='height' or sset[1]=='h':
+                        _config.set_graph_size(width=None, height=sset[2], perm=sperm)
+                    else:
+                        raise ValueError('invalid graph_size value')
+                else:
+                    if (sset[1]=='width' or sset[1]=='w') and (sset[3]=='height' or sset[3]=='h'):
+                        _config.set_graph_size(width=sset[2], height=sset[4], perm=sperm)
+                    elif (sset[1]=='height' or sset[1]=='h') and (sset[3]=='width' or sset[3]=='w'):
+                        _config.set_graph_size(width=sset[4], height=sset[2], perm=sperm)
+                    else:
+                        raise ValueError('invalid graph_size value')
+            elif settype=="graph_show":
+                if len(sset)!=2:
+                    raise SyntaxError('invalid graph_show set; only True or False allowed.')
+
+                if sset[1]=='True':
+                    _config.set_graph_show(show=True, perm=sperm)
+                elif sset[1]=='False':
+                    _config.set_graph_show(show=False, perm=sperm)
+                else:
+                    raise ValueError('invalid graph_show value')
+            elif settype=="graph_format":
+                if len(sset)!=2:
+                    raise SyntaxError('invalid graph_format set')
+
+                if sset[1]=='svg':
+                    _config.set_graph_format(gformat='svg', perm=sperm)
+                elif sset[1]=='png':
+                    _config.set_graph_format(gformat='png', perm=sperm)
+                elif sset[1]=='pdf':
+                    _config.set_graph_format(gformat='pdf', perm=sperm)
+                else:
+                    raise ValueError('invalid graph_format value; only svg, png, or pdf allowed.')
+            elif settype=="streaming_output_mode":
+                if len(sset)!=2:
+                    raise SyntaxError('invalid streaming_output_mode set')
+
+                if sset[1]=='on':
+                    _config.set_streaming_output_mode(flag='on', perm=sperm)
+                elif sset[1]=='off':
+                    _config.set_streaming_output_mode(flag='off', perm=sperm)
+                else:
+                    raise ValueError('invalid streaming_output_mode value; only on or off allowed.')
+            else:
+                raise SyntaxError('invalid set type')
+        else:
+            raise SyntaxError('invalid subcommand')
+
+try:
+    ip = get_ipython()
+    ip.register_magics(PyStataMagic)
+except AttributeError:
+    _config.stipython = 2
+    raise IPyKernelError('register_magics not found')

pystata/stata.py

@@ -0,0 +1,945 @@
+'''
+This module contains core functions used to interact with Stata.
+'''
+from __future__ import print_function
+from ctypes import c_char_p, c_void_p, cast
+
+from pystata import config
+config.check_initialized()
+
+if config.pyversion[0]<3:
+    from Queue import LifoQueue
+    from codecs import open
+else:
+    from queue import LifoQueue
+
+import sfi
+from pystata.core import stout
+import codeop
+import sys
+
+rc2 = 0
+gr_display_func = None
+has_num_pand = {
+    "pknum":  True,
+    "pkpand": True
+}
+
+try:
+    from pystata.core import numpy2stata
+except:
+    has_num_pand['pknum'] = False
+
+try:
+    from pystata.core import pandas2stata
+except:
+    has_num_pand['pkpand'] = False
+
+
+def _print_no_streaming_output(output, newline):
+    if config.pyversion[0] >= 3:
+        if newline:
+            print(output, file=config.stoutputf)
+        else:
+            print(output, end='', file=config.stoutputf)
+    else:
+        if newline:
+            print(config.get_encode_str(output), file=config.stoutputf)
+        else:
+            print(config.get_encode_str(output), end='', file=config.stoutputf)
+
+
+def _stata_wrk1(cmd, echo=False):
+    if config.stconfig['streamout']=='on':
+        try:
+            queue = LifoQueue()
+            outputter = stout.RepeatTimer('Stata', 1, queue, 0.015, None, None, None)
+            outputter.start()
+
+            with stout.RedirectOutput(stout.StataDisplay(), stout.StataError()):
+                rc1 = config.stlib.StataSO_Execute(config.get_encode_str(cmd), echo)
+
+            queue.put(rc1)
+
+            outputter.join()
+            outputter.done()
+        except KeyboardInterrupt:
+            outputter.done()
+            config.stlib.StataSO_SetBreak()
+            print('\nKeyboardInterrupt: --break--')
+    else:
+        try:
+            with stout.RedirectOutput(stout.StataDisplay(), stout.StataError()):
+                rc1 = config.stlib.StataSO_Execute(config.get_encode_str(cmd), echo)
+
+            output = config.get_output()
+            while len(output)!=0:
+                if rc1 != 0:
+                    raise SystemError(output)
+
+                _print_no_streaming_output(output, False)
+                output = config.get_output()
+            else:
+                if rc1 != 0:
+                    raise SystemError("failed to execute the specified command")
+        except KeyboardInterrupt:
+            config.stlib.StataSO_SetBreak()
+            print('\nKeyboardInterrupt: --break--')
+
+
+def _stata_wrk2(cmd, real_cmd, colon, mode):
+    global rc2
+    if config.stconfig['streamout']=='on':
+        try:
+            queue = LifoQueue()
+            outputter = stout.RepeatTimer('Stata', 2, queue, 0.015, real_cmd, colon, mode)
+            outputter.start()
+
+            with stout.RedirectOutput(stout.StataDisplay(), stout.StataError()):
+                rc2 = config.stlib.StataSO_Execute(config.get_encode_str(cmd), False)
+                
+            queue.put(rc2)
+
+            outputter.join()
+            outputter.done()
+        except KeyboardInterrupt:
+            outputter.done()
+            config.stlib.StataSO_SetBreak()
+            print('\nKeyboardInterrupt: --break--')
+    else:
+        try:
+            with stout.RedirectOutput(stout.StataDisplay(), stout.StataError()):
+                rc2 = config.stlib.StataSO_Execute(config.get_encode_str(cmd), False)
+
+            output = config.get_output()
+            if rc2 != 0:
+                if rc2 != 3000:
+                    if mode!=1:
+                        output = stout.output_get_interactive_result(output, real_cmd, colon, mode)
+                        _print_no_streaming_output(output, False)
+                    else:
+                        raise SystemError(config.get_encode_str(output))
+
+            else:
+                while len(output)!=0:
+                    output_tmp = config.get_output()
+                    if len(output_tmp)==0:
+                        if mode!=1:
+                            output = stout.output_get_interactive_result(output, real_cmd, colon, mode)
+                            _print_no_streaming_output(output, False)
+                        else:
+                            _print_no_streaming_output(output, True)
+                        break
+                    else:
+                        if mode!=1:
+                            output = stout.output_get_interactive_result(output, real_cmd, colon, mode)
+                            
+                        _print_no_streaming_output(output, False)
+                        output = output_tmp
+        except KeyboardInterrupt:
+            config.stlib.StataSO_SetBreak()
+            print('\nKeyboardInterrupt: --break--')
+
+
+def _get_user_input(uprompt):
+    if config.pyversion[0]==2:
+        return raw_input(uprompt)
+    else:
+        return input(uprompt)
+
+
+def run(cmd, quietly=False, echo=False, inline=None):
+    """
+    Run a single line or a block of Stata commands. 
+
+    If a single-line Stata command is specified, the command is run through 
+    Stata directly. If you need to run a multiple-line command or a block of 
+    Stata commands, enclose the commands within triple quotes, \""" or \'''. 
+    The set of commands will be placed in a temporary do-file and executed all 
+    at once. Because the commands are executed from a do-file, you can add comments 
+    and delimiters with the specified commands.
+
+    Parameters
+    ----------
+    cmd : str 
+        The commands to execute. 
+
+    quietly : bool, optional
+        Suppress output from Stata commands. Default is False. When set to 
+        True, output will be suppressed.
+
+    echo : bool, optional 
+        Echo the command. Default is False. This only affects the output when 
+        executing a single command.
+
+    inline : None, True, or False, optional
+        Specify whether to export and display the graphs generated by the 
+        commands, if there are any. If `inline` is not specified or specified as 
+        None, the global setting specified with 
+        :meth:`~pystata.config.set_graph_show` is applied.
+
+    Raises
+    ------
+    SystemError
+        This error can be raised if any of the specified Stata commands result 
+        in an error.
+    """
+    global rc2
+    config.check_initialized()
+
+    if inline is None:
+        inline = config.stconfig['grshow']
+    else:
+        if inline is not True and inline is not False:
+            raise TypeError('inline must be a boolean value')
+
+    config.stlib.StataSO_ClearOutputBuffer()
+    cmds = cmd.splitlines()
+    if len(cmds) == 0:
+        return 
+    elif len(cmds) == 1:
+        if inline:
+            config.stlib.StataSO_Execute(config.get_encode_str("qui _gr_list on"), False)
+
+        input_cmd = cmds[0].strip()
+        if input_cmd=="mata" or input_cmd=="mata:":
+            has_colon = False
+            if input_cmd=="mata:":
+                has_colon = True
+
+            print('. ' + input_cmd)
+            sfi.SFIToolkit.displayln("{hline 49} mata (type {cmd:end} to exit) {hline}")
+            incmd = _get_user_input(": ").strip()
+            incmds1 = ""
+            incmds2 = "" 
+            inprompt = ": "
+            while incmd!="end":
+                incmd = incmd + "\n"
+                incmds1 = incmds1 + incmd
+                incmd = inprompt + incmd
+                incmds2 = incmds2 + incmd
+
+                tmpf = sfi.SFIToolkit.getTempFile()
+                with open(tmpf, 'w', encoding="utf-8") as f:
+                    f.write(input_cmd+"\n")
+                    f.write(incmds1)
+                    f.write("end")
+
+                if quietly:
+                    _stata_wrk2("qui include " + tmpf, incmds2, has_colon, 2)
+                else:
+                    _stata_wrk2("include " + tmpf, incmds2, has_colon, 2)
+
+                if rc2 != 0:
+                    if rc2 != 3000:
+                        break
+                    else:
+                        incmd = _get_user_input("> ").strip()
+                        inprompt = "> "
+                else:
+                    incmd = _get_user_input(": ").strip()
+                    incmds1 = ""
+                    incmds2 = ""
+                    inprompt = ": "
+            else:
+                sfi.SFIToolkit.displayln("{hline}")
+        elif input_cmd=="python" or input_cmd=="python:":
+            has_colon = False
+            if input_cmd=="python:":
+                has_colon = True
+
+            print('. ' + input_cmd)
+            sfi.SFIToolkit.displayln("{hline 47} python (type {cmd:end} to exit) {hline}")
+            incmd = _get_user_input(">>> ")
+            incmds1 = ""
+            incmds2 = "" 
+            inprompt = ">>> "
+            while incmd!="end":
+                incmds1 = incmds1 + incmd
+                incmd = inprompt + incmd
+                incmds2 = incmds2 + incmd
+
+                if incmd[:6]!="stata:":
+                    res = incmd
+                    try:
+                        res = codeop.compile_command(incmds1, '<input>', 'single')
+                        incmds1 = incmds1 + "\n"
+                        incmds2 = incmds2 + "\n"
+                    except (OverflowError, SyntaxError, ValueError):
+                        pass
+                else: 
+                    res = incmd
+                   
+                if res is None:
+                    incmd = _get_user_input("... ")
+                    inprompt = "... "
+                else:
+                    tmpf = sfi.SFIToolkit.getTempFile()
+                    with open(tmpf, 'w', encoding="utf-8") as f:
+                        f.write(input_cmd+"\n")
+                        f.write(incmds1)
+                        f.write("end")
+					
+                    if quietly:
+                        _stata_wrk2("qui include " + tmpf, incmds2, has_colon, 3)
+                    else:
+                        _stata_wrk2("include " + tmpf, incmds2, has_colon, 3)
+
+                    if rc2 != 0:
+                        break
+
+                    incmd = _get_user_input(">>> ")
+                    incmds1 = ""
+                    incmds2 = ""
+                    inprompt = ">>> "						
+            else:
+                sfi.SFIToolkit.displayln("{hline}")
+        else:
+            if quietly:
+                _stata_wrk1("qui " + cmds[0], echo)
+            else:
+                _stata_wrk1(cmds[0], echo)
+    else:
+        if inline:
+            config.stlib.StataSO_Execute(config.get_encode_str("qui _gr_list on"), False)
+
+        tmpf = sfi.SFIToolkit.getTempFile()
+        with open(tmpf, 'w', encoding="utf-8") as f:
+            f.write(cmd)
+
+        if quietly:
+            _stata_wrk2("qui include " + tmpf, None, False, 1)
+        else:
+            _stata_wrk2("include " + tmpf, None, False, 1)
+
+    if inline:
+        if config.get_stipython()>=3:
+            global gr_display_func
+            if gr_display_func is None:
+                from pystata.ipython.grdisplay import display_stata_graph
+                gr_display_func = display_stata_graph
+
+            gr_display_func()
+
+        config.stlib.StataSO_Execute(config.get_encode_str("qui _gr_list off"), False)
+
+
+def nparray_to_data(arr, prefix='v', force=False):
+    """
+    Load a NumPy array into Stata's memory, making it the current dataset.
+
+    When the data type of the array conforms to a Stata variable type, this 
+    variable type will be used in Stata. Otherwise, each column of the array 
+    will be converted into a string variable in Stata.
+
+    By default, **v1**, **v2**, ... are used as the variable names in Stata. If 
+    `prefix` is specified, it will be used as the variable prefix for all the 
+    variables loaded into Stata.
+
+    If there is a dataset in memory and it has been changed since it was last 
+    saved, an attempt to load a NumPy array into Stata will raise an exception. 
+    The `force` argument will force loading of the array, replacing the dataset 
+    in memory.
+
+    Parameters
+    ----------
+    arr : NumPy array
+        The array to be loaded. 
+
+    prefix : str, optional
+        The string to be used as the variable prefix. Default is **v**. 
+
+    force : bool, optional 
+        Force loading of the array into Stata. Default is False. 
+
+    Raises
+    ------
+    SystemError
+        This error can be raised if there is a dataset in memory that has 
+        changed since it was last saved, and `force` is False.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    changed = sfi.Scalar.getValue('c(changed)')
+    if int(changed)==1 and force is False:
+        raise SystemError('no; dataset in memory has changed since last saved')
+
+    if int(changed)==0 or force is True:
+        run('clear')
+
+    numpy2stata.array_to_stata(arr, None, prefix)
+
+
+def pdataframe_to_data(df, force=False):
+    """
+    Load a pandas DataFrame into Stata's memory, making it the current dataset.
+
+    Each column of the DataFrame will be stored as a variable. If the column 
+    type conforms to a Stata variable type, the variable type will be used in 
+    Stata. Otherwise, the column will be converted into a string variable in 
+    Stata. 
+
+    The variable names will correspond to the column names of the DataFrame. If 
+    the column name is a valid Stata name, it will be used as the variable 
+    name. If it is not a valid Stata name, a valid variable name is created by 
+    using the 
+    `makeVarName() <https://www.stata.com/python/api17/SFIToolkit.html#sfi.SFIToolkit.makeVarName>`__ 
+    method of the `SFIToolkit <https://www.stata.com/python/api17/SFIToolkit.html>`__ 
+    class in the `Stata Function Interface (sfi) <https://www.stata.com/python/api17/>`__ module.
+
+    If there is a dataset in memory and it has been changed since it was last 
+    saved, an attempt to load a DataFrame into Stata will raise an exception. 
+    The `force` argument will force loading of the DataFrame, replacing the 
+    dataset in memory.
+
+    Parameters
+    ----------
+    df : pandas DataFrame
+        The DataFrame to be loaded.
+
+    force : bool, optional 
+        Force loading of the DataFrame into Stata. Default is False.
+
+    Raises
+    ------
+    SystemError
+        This error can be raised if there is a dataset in memory that has been 
+        changed since it was last saved, and `force` is False.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pkpand']:
+        raise SystemError('pandas package is required to use this function.')
+
+    changed = sfi.Scalar.getValue('c(changed)')
+    if int(changed)==1 and force is False:
+        raise SystemError('no; dataset in memory has changed since last saved')
+
+    if int(changed)==0 or force is True:
+        run('clear')
+
+    pandas2stata.dataframe_to_stata(df, None)
+
+
+class _DefaultMissing:
+    def __repr__(self):
+        return "_DefaultMissing()"
+
+
+def nparray_from_data(var=None, obs=None, selectvar=None, valuelabel=False, missingval=_DefaultMissing()):
+    """
+    Export values from the current Stata dataset into a NumPy array.
+
+    Parameters
+    ----------
+    var : int, str, or list-like, optional
+        Variables to access. It can be specified as a single variable
+        index or name, or an iterable of variable indices or names. 
+        If `var` is not specified, all the variables are specified.
+
+    obs : int or list-like, optional
+        Observations to access. It can be specified as a single 
+        observation index or an iterable of observation indices. 
+        If `obs` is not specified, all the observations are specified.
+
+    selectvar : int or str, optional
+        Observations for which `selectvar!=0` will be selected. If `selectvar`
+        is an integer, it is interpreted as a variable index. If `selectvar` 
+        is a string, it should contain the name of a Stata variable. 
+        Specifying `selectvar` as "" has the same result as not 
+        specifying `selectvar`, which means no observations are excluded. 
+        Specifying `selectvar` as -1 means that observations with missing 
+        values for the variables specified in `var` are to be excluded.
+
+    valuelabel : bool, optional
+        Use the value label when available. Default is False.
+
+    missingval : :ref:`_DefaultMissing <ref-defaultmissing>`, `optional`
+        If `missingval` is specified, all the missing values in the returned 
+        list are replaced by this value. If it is not specified, the numeric 
+        value of the corresponding missing value in Stata is returned.
+
+    Returns
+    -------
+    NumPy array
+        A NumPy array containing the values from the dataset in memory. 
+
+    Raises
+    ------
+    ValueError
+        This error can be raised for three possible reasons. One is if any of 
+        the variable indices or names specified in `var` are out of 
+        `range <https://www.stata.com/python/api17/Data.html#ref-datarange>`__ 
+        or not found. Another is if any of the observation indices specified 
+        in `obs` are out of range. Last, it may be raised if `selectvar` is out of 
+        range or not found.
+
+
+    .. _ref-defaultmissing:
+
+    Notes
+    -----
+    The definition of the utility class **_DefaultMissing** is as follows::
+
+        class _DefaultMissing:
+            def __repr__(self):
+                return "_DefaultMissing()"
+
+    This class is defined only for the purpose of specifying the default 
+    value for the parameter `missingval` of the above function. Users are 
+    not recommended to use this class for any other purpose.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    if isinstance(missingval, _DefaultMissing):
+        return numpy2stata.array_from_stata(None, var, obs, selectvar, valuelabel, None)
+    else:
+        return numpy2stata.array_from_stata(None, var, obs, selectvar, valuelabel, missingval)
+
+
+def pdataframe_from_data(var=None, obs=None, selectvar=None, valuelabel=False, missingval=_DefaultMissing()):
+    """
+    Export values from the current Stata dataset into a pandas DataFrame.
+
+    Parameters
+    ----------
+    var : int, str, or list-like, optional
+        Variables to access. It can be specified as a single variable
+        index or name, or an iterable of variable indices or names. 
+        If `var` is not specified, all the variables are specified.
+
+    obs : int or list-like, optional
+        Observations to access. It can be specified as a single 
+        observation index or an iterable of observation indices. 
+        If `obs` is not specified, all the observations are specified.
+
+    selectvar : int or str, optional
+        Observations for which `selectvar!=0` will be selected. If `selectvar`
+        is an integer, it is interpreted as a variable index. If `selectvar` 
+        is a string, it should contain the name of a Stata variable. 
+        Specifying `selectvar` as "" has the same result as not 
+        specifying `selectvar`, which means no observations are excluded. 
+        Specifying `selectvar` as -1 means that observations with missing 
+        values for the variables specified in `var` are to be excluded.
+
+    valuelabel : bool, optional
+        Use the value label when available. Default is False.
+
+    missingval : :ref:`_DefaultMissing <ref-defaultmissing>`, `optional`
+        If `missingval` is specified, all the missing values in the returned 
+        list are replaced by this value. If it is not specified, the numeric 
+        value of the corresponding missing value in Stata is returned.
+
+    Returns
+    -------
+    pandas DataFrame
+        A pandas DataFrame containing the values from the dataset in memory.  
+
+    Raises
+    ------
+    ValueError
+        This error can be raised for three possible reasons. One is if any of 
+        the variable indices or names specified in `var` are out of 
+        `range <https://www.stata.com/python/api17/Data.html#ref-datarange>`__ 
+        or not found. Another is if any of the observation indices specified 
+        in `obs` are out of range. Last, it may be raised if `selectvar` is out of 
+        range or not found.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pkpand']:
+        raise SystemError('pandas package is required to use this function.')
+
+    if isinstance(missingval, _DefaultMissing):
+        return(pandas2stata.dataframe_from_stata(None, var, obs, selectvar, valuelabel, None))
+    else:
+        return(pandas2stata.dataframe_from_stata(None, var, obs, selectvar, valuelabel, missingval))
+
+
+def nparray_to_frame(arr, stfr, prefix='v', force=False):
+    """
+    Load a NumPy array into a specified frame in Stata.
+
+    When the data type of the array conforms to a Stata variable type, this 
+    variable type will be used in the frame. Otherwise, each column of the 
+    array will be converted into a string variable in the frame.
+
+    By default, **v1**, **v2**, ... are used as the variable names in the frame. 
+    If `prefix` is specified, it will be used as the variable prefix for all the 
+    variables loaded into the frame.
+
+    If the frame of the specified name already exists in Stata, an attempt to load 
+    a NumPy array into the frame will raise an exception. The `force` argument will 
+    force loading of the array, replacing the original frame.
+
+    Parameters
+    ----------
+    arr : NumPy array
+        The array to be loaded. 
+
+    stfr : str 
+        The frame in which to store the array. 
+
+    prefix : str, optional
+        The string to be used as the variable prefix. Default is **v**. 
+
+    force : bool, optional 
+        Force loading of the array into the frame if the frame already exists. 
+        Default is False.
+
+    Raises
+    ------
+    SystemError
+        This error can be raised if the specified frame already exists in 
+        Stata, and `force` is False.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    stframe = None
+    try:
+	    stframe = sfi.Frame.connect(stfr)
+    except:
+        pass
+
+    if stframe is not None:
+        if force is False:
+            raise SystemError('%s already exists.' % stfr)
+
+        stframe.drop()
+
+    numpy2stata.array_to_stata(arr, stfr, prefix)
+
+
+def pdataframe_to_frame(df, stfr, force=False):
+    """
+    Load a pandas DataFrame into a specified frame in Stata.  
+
+    Each column of the DataFrame will be stored as a variable in the frame. 
+    If the column type conforms to a Stata variable type, the variable type 
+    will be used in the frame. Otherwise, the column will be converted into a 
+    string variable in the frame.
+
+    The variable names will correspond to the column names of the DataFrame. 
+    If the column name is a valid Stata name, it will be used as the 
+    variable name. If it is not a valid Stata name, a valid variable name is 
+    created by using 
+    the `makeVarName() <https://www.stata.com/python/api17/SFIToolkit.html#sfi.SFIToolkit.makeVarName>`__ 
+    method of the `SFIToolkit <https://www.stata.com/python/api17/SFIToolkit.html>`__ 
+    class in the `Stata Function Interface (sfi) <https://www.stata.com/python/api17/>`__ module.
+
+    If the frame of the specified name already exists in Stata, an attempt to 
+    load a pandas DataFrame into the frame will raise an exception. The `force` 
+    argument will force loading of the DataFrame, replacing the original frame.
+
+    Parameters
+    ----------
+    df : pandas DataFrame
+        The DataFrame to be loaded. 
+
+    stfr : str 
+        The frame in which to store the DataFrame. 
+
+    force : bool, optional 
+        Force loading of the DataFrame into the frame if the frame already 
+        exists. Default is False.
+
+    Raises
+    ------
+    SystemError
+        This error can be raised if the specified frame already exists 
+        in Stata, and `force` is False.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pkpand']:
+        raise SystemError('pandas package is required to use this function.')
+
+    stframe = None
+    try:
+	    stframe = sfi.Frame.connect(stfr)
+    except:
+        pass
+
+    if stframe is not None:
+        if force is False:
+            raise SystemError('%s already exists.' % stfr)
+
+        stframe.drop()
+
+    pandas2stata.dataframe_to_stata(df, stfr)
+
+
+def nparray_from_frame(stfr, var=None, obs=None, selectvar=None, valuelabel=False, missingval=_DefaultMissing()):
+    """
+    Export values from a Stata frame into a NumPy array.
+
+    Parameters
+    ----------
+    stfr : str
+        The Stata frame to export. 
+
+    var : int, str, or list-like, optional
+        Variables to access. It can be specified as a single variable
+        index or name, or an iterable of variable indices or names. 
+        If `var` is not specified, all the variables are specified.
+
+    obs : int or list-like, optional
+        Observations to access. It can be specified as a single 
+        observation index or an iterable of observation indices. 
+        If `obs` is not specified, all the observations are specified.
+
+    selectvar : int or str, optional
+        Observations for which `selectvar!=0` will be selected. If `selectvar`
+        is an integer, it is interpreted as a variable index. If `selectvar` 
+        is a string, it should contain the name of a Stata variable. 
+        Specifying `selectvar` as "" has the same result as not 
+        specifying `selectvar`, which means no observations are excluded. 
+        Specifying `selectvar` as -1 means that observations with missing 
+        values for the variables specified in `var` are to be excluded.
+
+    valuelabel : bool, optional
+        Use the value label when available. Default is False.
+
+    missingval : :ref:`_DefaultMissing <ref-defaultmissing>`, `optional`
+        If `missingval` is specified, all the missing values in the returned 
+        list are replaced by this value. If it is not specified, the numeric 
+        value of the corresponding missing value in Stata is returned.
+
+    Returns
+    -------
+    NumPy array
+        A NumPy array containing the values from the Stata frame. 
+
+    Raises
+    ------
+    ValueError
+        This error can be raised for three possible reasons. One is if any 
+        of the variable indices or names specified in `var` are out of 
+        `range <https://www.stata.com/python/api17/Frame.html#ref-framerange>`__ 
+        or not found. Another is if any of the observation indices specified 
+        in `obs` are out of range. Last, it may be raised if `selectvar` is out of 
+        range or not found.
+
+    FrameError
+        This `error <https://www.stata.com/python/api17/FrameError.html#sfi.FrameError>`__ 
+        can be raised if the frame `stfr` does not already exist in Stata, or 
+        if Python fails to connect to the frame.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    if isinstance(missingval, _DefaultMissing):
+        return numpy2stata.array_from_stata(stfr, var, obs, selectvar, valuelabel, None)
+    else:
+        return numpy2stata.array_from_stata(stfr, var, obs, selectvar, valuelabel, missingval)
+
+
+def pdataframe_from_frame(stfr, var=None, obs=None, selectvar=None, valuelabel=False, missingval=_DefaultMissing()):
+    """
+    Export values from a Stata frame into a pandas DataFrame.
+
+    Parameters
+    ----------
+    stfr : str
+        The Stata frame to export. 
+
+    var : int, str, or list-like, optional
+        Variables to access. It can be specified as a single variable
+        index or name, or an iterable of variable indices or names. 
+        If `var` is not specified, all the variables are specified.
+
+    obs : int or list-like, optional
+        Observations to access. It can be specified as a single 
+        observation index or an iterable of observation indices. 
+        If `obs` is not specified, all the observations are specified.
+
+    selectvar : int or str, optional
+        Observations for which `selectvar!=0` will be selected. If `selectvar`
+        is an integer, it is interpreted as a variable index. If `selectvar` 
+        is a string, it should contain the name of a Stata variable. 
+        Specifying `selectvar` as "" has the same result as not 
+        specifying `selectvar`, which means no observations are excluded. 
+        Specifying `selectvar` as -1 means that observations with missing 
+        values for the variables specified in `var` are to be excluded.
+
+    valuelabel : bool, optional
+        Use the value label when available. Default is False.
+
+    missingval : :ref:`_DefaultMissing <ref-defaultmissing>`, `optional`
+        If `missingval` is specified, all the missing values in the returned 
+        list are replaced by this value. If it is not specified, the numeric 
+        value of the corresponding missing value in Stata is returned.
+
+    Returns
+    -------
+    pandas DataFrame
+        A pandas DataFrame containing the values from the Stata frame. 
+
+    Raises
+    ------
+    ValueError
+        This error can be raised for three possible reasons. One is if any of 
+        the variable indices or names specified in `var` are out of 
+        `range <https://www.stata.com/python/api17/Frame.html#ref-framerange>`__ 
+        or not found. Another is if any of the observation indices specified 
+        in `obs` are out of range. Last, it may be raised if `selectvar` is out of 
+        range or not found.
+
+    FrameError
+        This `error <https://www.stata.com/python/api17/FrameError.html#sfi.FrameError>`__  
+        can be raised if the frame `stfr` does not already exist in Stata, 
+        or if Python fails to connect to the frame.
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pkpand']:
+        raise SystemError('pandas package is required to use this function.')
+
+    if isinstance(missingval, _DefaultMissing):
+        return(pandas2stata.dataframe_from_stata(stfr, var, obs, selectvar, valuelabel, None))
+    else:
+        return(pandas2stata.dataframe_from_stata(stfr, var, obs, selectvar, valuelabel, missingval))
+
+
+def _get_return_val(res, cat):
+    if cat=="r()":
+        rrscalar = sfi.SFIToolkit.listReturn("r()", "scalar")
+        rscalar = rrscalar.split()
+        for rs in rscalar:
+            rs = "r(" + rs + ")"
+            val = sfi.Scalar.getValue(rs)
+            res[rs] = val
+
+        rrmac = sfi.SFIToolkit.listReturn("r()", "macro")
+        rmac = rrmac.split()
+        for rs in rmac:
+            rs = "r(" + rs + ")"
+            val = sfi.Macro.getGlobal(rs)
+            res[rs] = val
+
+        rrmat = sfi.SFIToolkit.listReturn("r()", "matrix")
+        rmat = rrmat.split()
+        for rm in rmat:
+            rm = "r(" + rm + ")"
+            val = numpy2stata.array_from_matrix(sfi.Matrix.get(rm))
+            res[rm] = val
+
+    elif cat=="e()":
+        eenum = sfi.SFIToolkit.listReturn("e()", "scalar")
+        enum = eenum.split()
+        for en in enum:
+            en = "e(" + en + ")"
+            val = sfi.Scalar.getValue(en)
+            res[en] = val
+
+        eestr = sfi.SFIToolkit.listReturn("e()", "macro")
+        estr = eestr.split()
+        for es in estr:
+            es = "e(" + es + ")"
+            val = sfi.Macro.getGlobal(es)
+            res[es] = val
+
+        eemat = sfi.SFIToolkit.listReturn("e()", "matrix")
+        emat = eemat.split()
+        for em in emat:
+            em = "e(" + em + ")"
+            val = numpy2stata.array_from_matrix(sfi.Matrix.get(em))
+            res[em] = val
+
+    else:
+        ssmac = sfi.SFIToolkit.listReturn("s()", "macro")
+        smac = ssmac.split()
+        for ss in smac:
+            ss = "s(" + ss + ")"
+            val = sfi.Macro.getGlobal(ss)
+            res[ss] = val
+
+    return res
+
+	
+def get_return():
+    """
+    Retrieve current **r()** results and store them in a Python dictionary.
+
+    The keys are Stata's macro and scalar names, and the values are their 
+    corresponding values. Stata's matrices are converted into NumPy arrays. 
+
+    Returns
+    -------
+    Dictionary
+        A dictionary containing current **r()** results. 
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    res = {}
+    _get_return_val(res, "r()")
+    return res
+
+
+def get_ereturn():
+    """
+    Retrieve current **e()** results and store them in a Python dictionary.
+
+    The keys are Stata's macro and scalar names, and the values are their 
+    corresponding values. Stata's matrices are converted into NumPy arrays. 
+
+    Returns
+    -------
+    Dictionary
+        A dictionary containing current **e()** results. 
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+
+    res = {}
+    _get_return_val(res, "e()")
+    return res
+
+
+def get_sreturn():
+    """
+    Retrieve current **s()** results and store them in a Python dictionary.
+
+    The keys are Stata's macro and scalar names, and the values are their 
+    corresponding values. Stata's matrices are converted into NumPy arrays. 
+
+    Returns
+    -------
+    Dictionary
+        A dictionary containing current **s()** results. 
+    """
+    global has_num_pand
+    config.check_initialized()
+
+    if not has_num_pand['pknum']:
+        raise SystemError('NumPy package is required to use this function.')
+	
+    res = {}
+    _get_return_val(res, "s()")
+    return res

pystata/stexception.py

@@ -0,0 +1,19 @@
+class PyStataError(Exception):
+    """
+    This class is the base class for other exceptions defined in this module.
+    """
+    pass
+
+
+class IPythonError(PyStataError):
+    """
+    The class is used to indicate whether the system has IPython support.
+    """
+    pass
+
+class IPyKernelError(PyStataError):
+    """
+    The class is used to indicate whether pystata is running in IPython 
+    interactive session.
+    """
+    pass

pystata/version.py

@@ -0,0 +1,2 @@
+version = '0.1.0'
+author = 'StataCorp LLC'