| | ''' |
| | 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() |
| |
|
| |
|
