Metadata-Version: 2.1
Name: formulas
Version: 1.0.0
Summary: Parse and compile Excel formulas and workbooks in python code.
Home-page: https://github.com/vinci1it2000/formulas
Author: Vincenzo Arcidiacono
Author-email: vinci1it2000@gmail.com
License: EUPL 1.1+
Download-URL: https://github.com/vinci1it2000/formulas/tarball/v1.0.0
Project-URL: Documentation, http://formulas.readthedocs.io
Project-URL: Issue tracker, https://github.com/vinci1it2000/formulas/issues
Project-URL: Donate, https://donorbox.org/formulas
Description: .. _start-intro:
        
        
        What is formulas?
        *****************
        
        **formulas** implements an interpreter for Excel formulas, which
        parses and compile Excel formulas expressions.
        
        Moreover, it compiles Excel workbooks to python and executes without
        using the Excel COM server. Hence, **Excel is not needed**.
        
        
        Installation
        ************
        
        To install it use (with root privileges):
        
        ::
        
           $ pip install formulas
        
        Or download the last git version and use (with root privileges):
        
        ::
        
           $ python setup.py install
        
        
        Install extras
        ==============
        
        Some additional functionality is enabled installing the following
        extras:
        
        * excel: enables to compile Excel workbooks to python and execute
           using: ``ExcelModel``.
        
        * plot: enables to plot the formula ast and the Excel model.
        
        To install formulas and all extras, do:
        
        ::
        
           $ pip install formulas[all]
        
        .. _end-quick:
        
        
        Basic Examples
        **************
        
        The following sections will show how to:
        
        * parse a Excel formulas;
        
        * load, compile, and execute a Excel workbook;
        
        * extract a sub-model from a Excel workbook;
        
        * add a custom function.
        
        
        Parsing formula
        ===============
        
        An example how to parse and execute an Excel formula is the following:
        
        >>> import formulas
        >>> func = formulas.Parser().ast('=(1 + 1) + B3 / A2')[1].compile()
        
        To visualize formula model and get the input order you can do the
        following:
        
        >>> list(func.inputs)
        ['A2', 'B3']
        >>> func.plot(view=False)  # Set view=True to plot in the default browser.
        SiteMap([(=((1 + 1) + (B3 / A2)), SiteMap())])
        
        [graph]
        
        Finally to execute the formula and plot the workflow:
        
        >>> func(1, 5)
        Array(7.0, dtype=object)
        >>> func.plot(workflow=True, view=False)  # Set view=True to plot in the default browser.
        SiteMap([(=((1 + 1) + (B3 / A2)), SiteMap())])
        
        [graph]
        
        
        Excel workbook
        ==============
        
        An example how to load, calculate, and write an Excel workbook is the
        following:
        
        ::
        
           >>> import formulas
           >>> fpath, dir_output = 'excel.xlsx', 'output'  
           >>> xl_model = formulas.ExcelModel().loads(fpath).finish()
           >>> xl_model.calculate()
           Solution(...)
           >>> xl_model.write(dirpath=dir_output)
           {'EXCEL.XLSX': {Book: <openpyxl.workbook.workbook.Workbook ...>}}
        
        Tip: If you have or could have **circular references**, add
           *circular=True* to *finish* method.
        
        To plot the dependency graph that depict relationships between Excel
        cells:
        
        >>> dsp = xl_model.dsp
        >>> dsp.plot(view=False)  # Set view=True to plot in the default browser.
        SiteMap([(ExcelModel, SiteMap(...))])
        
        [graph]
        
        To overwrite the default inputs that are defined by the excel file or
        to impose some value to a specific cell:
        
        >>> xl_model.calculate(
        ...     inputs={
        ...         "'[EXCEL.XLSX]DATA'!A2": 3,  # To overwrite the default value.
        ...         "'[EXCEL.XLSX]DATA'!B3": 1  # To impose a value to B3 cell.
        ...     },
        ...     outputs=[
        ...        "'[EXCEL.XLSX]DATA'!C2", "'[EXCEL.XLSX]DATA'!C4"
        ...     ] # To define the outputs that you want to calculate.
        ... )
        Solution([("'[EXCEL.XLSX]DATA'!A2", <Ranges>('[EXCEL.XLSX]DATA'!A2)=[[3]]),
                  ("'[EXCEL.XLSX]DATA'!A3", <Ranges>('[EXCEL.XLSX]DATA'!A3)=[[6]]),
                  ("'[EXCEL.XLSX]DATA'!B3", <Ranges>('[EXCEL.XLSX]DATA'!B3)=[[1]]),
                  ("'[EXCEL.XLSX]DATA'!D2", <Ranges>('[EXCEL.XLSX]DATA'!D2)=[[1]]),
                  ("'[EXCEL.XLSX]DATA'!B2", <Ranges>('[EXCEL.XLSX]DATA'!B2)=[[9.0]]),
                  ("'[EXCEL.XLSX]DATA'!D3", <Ranges>('[EXCEL.XLSX]DATA'!D3)=[[2.0]]),
                  ("'[EXCEL.XLSX]DATA'!C2", <Ranges>('[EXCEL.XLSX]DATA'!C2)=[[10.0]]),
                  ("'[EXCEL.XLSX]DATA'!D4", <Ranges>('[EXCEL.XLSX]DATA'!D4)=[[3.0]]),
                  ("'[EXCEL.XLSX]DATA'!C4", <Ranges>('[EXCEL.XLSX]DATA'!C4)=[[4.0]])])
        
        To build a single function out of an excel model with fixed inputs and
        outputs, you can use the *compile* method of the *ExcelModel* that
        returns a `DispatchPipe
        <https://schedula.readthedocs.io/en/master/_build/schedula/utils/dsp/schedula.utils.dsp.DispatchPipe.html#schedula.utils.dsp.DispatchPipe>`_.
        This is a function where the inputs and outputs are defined by the
        data node ids (i.e., cell references).
        
        >>> func = xl_model.compile(
        ...     inputs=[
        ...         "'[EXCEL.XLSX]DATA'!A2",  # First argument of the function.
        ...         "'[EXCEL.XLSX]DATA'!B3"   # Second argument of the function.
        ...     ], # To define function inputs.
        ...     outputs=[
        ...         "'[EXCEL.XLSX]DATA'!C2", "'[EXCEL.XLSX]DATA'!C4"
        ...     ] # To define function outputs.
        ... )
        >>> func
        <schedula.utils.dsp.DispatchPipe object at ...>
        >>> [v.value[0, 0] for v in func(3, 1)]  # To retrieve the data.
        [10.0, 4.0]
        >>> func.plot(view=False)  # Set view=True to plot in the default browser.
        SiteMap([(ExcelModel, SiteMap(...))])
        
        [graph]
        
        
        Custom functions
        ================
        
        An example how to add a custom function to the formula parser is the
        following:
        
        >>> import formulas
        >>> FUNCTIONS = formulas.get_functions()
        >>> FUNCTIONS['MYFUNC'] = lambda x, y: 1 + y + x
        >>> func = formulas.Parser().ast('=MYFUNC(1, 2)')[1].compile()
        >>> func()
        4
        
Keywords: python,utility,library,excel,formulas,processing,calculation,dependencies,resolution,scientific,engineering,dispatch,compiling
Platform: UNKNOWN
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Development Status :: 4 - Beta
Classifier: Natural Language :: English
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: European Union Public Licence 1.1 (EUPL 1.1)
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Operating System :: Unix
Classifier: Operating System :: OS Independent
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Utilities
Provides-Extra: excel
Provides-Extra: plot
Provides-Extra: all
Provides-Extra: dev
