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