functioneer 0.0.1__tar.gz

functioneer-0.0.1/LICENSE

@@ -0,0 +1,26 @@
+Proprietary Software License
+----------------------------
+
+Software: functioneer (Functioneer)
+Author: Quinn Marsh
+Copyright: © [2024] Quinn Marsh
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute copies of the Software, subject to the following conditions:
+
+1. Attribution: All copies, substantial portions of the Software, and derivative works must include this original copyright notice, the name of the author(s), and a link to the original repository.
+
+2. Non-commercial Use: The Software may not be used, in whole or in part, for commercial purposes without explicit permission from the copyright holder.
+
+3. No Warranty: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+4. No Misrepresentation: Users of the Software shall not misrepresent the origin of the Software and should clearly indicate any modifications made.
+
+By using, copying, modifying, or distributing this Software, you agree to the terms and conditions outlined above.
+
+
+For details on using the Software within the terms of this license, please contact Quinn Marsh.
+
+Quinn Marsh
+[quinnmarsh@hotmail.com, X @qthedoc]

functioneer-0.0.1/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: functioneer
+Version: 0.0.1
+Summary: Functioneer is a Python package that simplifies the setup of automated analyses for your functions.
+Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
+Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
+License: Proprietary Software License
+        ----------------------------
+        
+        Software: functioneer (Functioneer)
+        Author: Quinn Marsh
+        Copyright: © [2024] Quinn Marsh
+        
+        All rights reserved.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute copies of the Software, subject to the following conditions:
+        
+        1. Attribution: All copies, substantial portions of the Software, and derivative works must include this original copyright notice, the name of the author(s), and a link to the original repository.
+        
+        2. Non-commercial Use: The Software may not be used, in whole or in part, for commercial purposes without explicit permission from the copyright holder.
+        
+        3. No Warranty: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+        4. No Misrepresentation: Users of the Software shall not misrepresent the origin of the Software and should clearly indicate any modifications made.
+        
+        By using, copying, modifying, or distributing this Software, you agree to the terms and conditions outlined above.
+        
+        
+        For details on using the Software within the terms of this license, please contact Quinn Marsh.
+        
+        Quinn Marsh
+        [quinnmarsh@hotmail.com, X @qthedoc]
+        
+Project-URL: Homepage, https://github.com/qthedoc/functioneer
+Project-URL: Issues, https://github.com/qthedoc/functioneer/issues
+Project-URL: Funding, https://donate.pypi.org
+Project-URL: Say Thanks!, http://quinnmarsh.com
+Keywords: functioneer,analysis,automation,autorun
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.18.5
+Requires-Dist: scipy>=1.5.2
+Requires-Dist: pandas>=1.0.5
+
+# Functioneer
+
+**Author**: Quinn Marsh  
+**Date**: October 21, 2024  
+
+Functioneer is a powerful Python package that simplifies the setup of automated analyses for your functions. With Functioneer, you can configure and execute functions with unlimited combinations of inputs, making it perfect for optimizations, parameter sweeps, testing, and any scenario where you need to test a function(s) over a wide range of inputs.
+
+## Features
+
+- **Fast Setup**: Define inputs, configurations, and combinations in seconds.
+- **Automated Execution**: Run functions with diverse parameter combinations, reducing repetitive setup.
+- **Flexible Input Handling**: Supports a variety of input types for complex analyses.
+- **Combinatorial Efficiency**: Specify ranges and conditions to create the full space of function possibilities.
+- **Output Management**: Easily retrieve and analyze the output of all function executions.
+
+## Installation
+
+Install Functioneer directly from PyPI:
+
+```
+pip install functioneer
+```
+
+## Documentation
+For full documentation on setting up Functioneer, customizing parameters, and handling outputs, visit the documentation site.
+
+## License
+Functioneer is released as open-source software with a custom license. Please see the LICENSE file for usage guidelines.

functioneer-0.0.1/README.md

@@ -0,0 +1,28 @@
+# Functioneer
+
+**Author**: Quinn Marsh  
+**Date**: October 21, 2024  
+
+Functioneer is a powerful Python package that simplifies the setup of automated analyses for your functions. With Functioneer, you can configure and execute functions with unlimited combinations of inputs, making it perfect for optimizations, parameter sweeps, testing, and any scenario where you need to test a function(s) over a wide range of inputs.
+
+## Features
+
+- **Fast Setup**: Define inputs, configurations, and combinations in seconds.
+- **Automated Execution**: Run functions with diverse parameter combinations, reducing repetitive setup.
+- **Flexible Input Handling**: Supports a variety of input types for complex analyses.
+- **Combinatorial Efficiency**: Specify ranges and conditions to create the full space of function possibilities.
+- **Output Management**: Easily retrieve and analyze the output of all function executions.
+
+## Installation
+
+Install Functioneer directly from PyPI:
+
+```
+pip install functioneer
+```
+
+## Documentation
+For full documentation on setting up Functioneer, customizing parameters, and handling outputs, visit the documentation site.
+
+## License
+Functioneer is released as open-source software with a custom license. Please see the LICENSE file for usage guidelines.

functioneer-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "functioneer"
+version = "0.0.1"
+authors = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
+maintainers = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
+description = "Functioneer is a Python package that simplifies the setup of automated analyses for your functions."
+readme = "README.md"
+license = { file = "LICENSE" }
+keywords = ["functioneer", "analysis", "automation", "autorun"]
+requires-python = ">=3.10"
+dependencies = [
+  "numpy>=1.18.5",
+  "scipy>=1.5.2",
+  "pandas>=1.0.5"
+]
+
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering",
+  "Programming Language :: Python :: 3.6",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/qthedoc/functioneer"
+"Issues" = "https://github.com/qthedoc/functioneer/issues"
+"Funding" = "https://donate.pypi.org"
+"Say Thanks!" = "http://quinnmarsh.com"

functioneer-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

functioneer-0.0.1/src/functioneer/__init__.py

@@ -0,0 +1,6 @@
+# functioneer/__init__.py
+
+# Import specific functions and classes from your modules
+
+from functioneer.analysis import AnalysisModule, AnalysisStep, Define, Fork, Execute, Optimize
+from functioneer.parameter import Parameter

functioneer-0.0.1/src/functioneer/analysis.py

@@ -0,0 +1,388 @@
+from typing import Callable
+import logging
+import copy
+import pandas as pd
+from datetime import datetime
+from time import time
+import numpy as np
+from scipy.optimize import minimize
+
+
+from functioneer.parameter import ParameterSet, Parameter
+from functioneer.util import call_with_matched_kwargs
+
+class AnalysisStep():
+    """
+    Template AnalysisStep object containing basic info
+    """
+    def __init__(self, condition: Callable[..., bool] | None = None) -> None:
+        if condition is not None and not isinstance(condition, Callable):
+            raise ValueError(f"AnalysisStep condition must be a function that returns a bool")
+        
+        self.condition = condition
+
+        # self.branch_cnt = 1
+
+    def run(self, paramset: ParameterSet):
+        """
+        template method for executing the AnalysisStep
+        returns a list of one or more ParameterSets that have been altered according to the AnalysisStep
+        returns a tuple of one or more parametersets
+
+        TODO decide if Default behavior is to COPY or PASS the paramset
+
+        validates paramset
+        """
+        if not isinstance(paramset, ParameterSet):
+            # logging.error(f"paramset is not of type ParameterSet")
+            raise ValueError(f"paramset is not of type ParameterSet")
+
+        return (paramset,)
+    
+class Define(AnalysisStep):
+    """
+    Define AnalysisStep: Adds parameter to parameterset
+    Will create new Parameter in ParameterSet if one does not already exist.
+    """
+    def __init__(self, 
+            name: str,
+            value = None,
+            # func = None,
+            # func_output_mode = 'single',
+            condition = None
+        ):
+        super().__init__(condition)
+
+        if isinstance(name, str):
+            self.parameter = Parameter(name, value)
+
+        # elif isinstance(param, Parameter):
+        #     pass
+
+        else:
+            logging.error(f"param must be of type Parameter")
+
+    def run(self, paramset):
+        # Validate
+        super().run(paramset)
+
+        # add new Parameter to Paramset
+        paramset.add_param(self.parameter)
+        
+        return (paramset,)
+    
+class Fork(AnalysisStep):
+    """
+    Fork AnalysisStep: Splits analysis into several parallel analysis based on the provided parameters and values.
+    Will create new Parameter in ParameterSet if one does not already exist.
+    """
+    def __init__(self, 
+            param_ids,
+            value_sets, # value_sets
+            condition = None
+            ):
+        super().__init__(condition)
+
+        # Handle single parameter id
+        if Parameter.is_valid_id(param_ids):
+            self.param_ids = (param_ids,)
+            value_sets = (value_sets,)
+            
+        # Handle multiple param ids
+        elif isinstance(param_ids, (tuple, list)) and all([Parameter.is_valid_id(id) for id in param_ids]):
+            self.param_ids = param_ids
+            
+        else:
+            raise ValueError(f"Fork param_ids must be a valid param id or a tuple of valid param ids")
+        
+        # Identify number of parameters
+        self.param_cnt = len(self.param_ids)
+
+        # Validate same number of params and value sets
+        if len(self.param_ids) != len(value_sets):
+            raise ValueError(f"Invalid Fork (param_ids='{self.param_ids}'): Mismatch between number of parameters and number or value sets.")
+        
+        self.value_cnt = len(value_sets[0])
+        for vs in value_sets:
+            if len(vs) != self.value_cnt:
+                raise ValueError(f"Invalid Fork (param_ids='{self.param_ids}'): Each parameter's value set must be the same length")
+
+        self.value_sets = value_sets
+
+        # TODO Validate value types
+        # this will be optional but left alone and values are tuples then it might be good to throw a warning in case user meant 
+        # raise ValueError(f"Warning: values of paramfork are of type 'tuple'. to silence this error set Parameter.value_type tot tuple")
+
+    def run(self, paramset: dict[str, Parameter]):
+        super().run(paramset)
+        
+        # Do forky stuff
+        
+        next_paramsets = []
+        for branch_idx in range(self.value_cnt):
+            ps: ParameterSet = copy.deepcopy(paramset)
+            for id, vs in zip(self.param_ids, self.value_sets):
+                val = vs[branch_idx]
+                ps.update_param(id, val)
+
+            next_paramsets.append(ps)
+
+        return next_paramsets
+    
+class Execute(AnalysisStep):
+    """
+    Execute AnalysisStep: Executes provided function using matched kwargs and sets parameters based on returned dict
+    """
+    def __init__(self,
+            func: Callable,
+            output_param_ids: str = None,
+            input_param_ids: str = None,
+            condition = None
+        ):
+        super().__init__(condition)
+
+        self.func = func
+
+        if output_param_ids is None:
+            self.output_param_ids = output_param_ids
+        elif Parameter.is_valid_id(output_param_ids):
+            self.output_param_ids = output_param_ids
+        elif Parameter.is_valid_id_iterable(output_param_ids):
+            self.output_param_ids = output_param_ids
+        else:
+            raise ValueError(f"Execute Step's output_param_ids must be a str or tuple of str")
+
+        self.input_param_ids = input_param_ids
+
+    def run(self, paramset):
+        """
+        Executes funciton and modifies paramset
+
+        TODO future args: auto_add_new_args=True
+        """
+        super().run(paramset)
+
+        # TODO might need to deepcopy params is preservation of the upper level is needed
+        next_paramset = copy.deepcopy(paramset)
+
+        # Execute function: Positional argument input mode
+        if self.input_param_ids:
+            output = next_paramset.call_with_positional_args(func=self.func, param_ids=self.input_param_ids)
+        
+        # Execute function: Keyword argument input mode
+        else: 
+            output = next_paramset.call_with_matched_kwargs(func=self.func)
+
+        # Process output: Direct output mode
+        if self.output_param_ids and isinstance(self.output_param_ids, str):
+            next_paramset.update_param(id=self.output_param_ids, value=output)
+
+        # Process output: Positional output mode
+        elif self.output_param_ids:
+            if len(self.output_param_ids) != len(output):
+                raise ValueError(f"Number of function outputs ({len(output)}) does not match the specified output_param_ids ({len(self.output_param_ids)})")
+            
+            for i, id in enumerate(self.output_param_ids):
+                next_paramset.update_param(id=id, value=output[i])
+
+        # Process output: Keyword output mode
+        else:
+            if not isinstance(output, dict):
+                raise ValueError(f"function in step {69} does not return valid dict of param names and values")
+                        
+            # next_paramsets.update_values(results)
+
+            # TODO this should be funcitonalized
+            # paramset.update_param_values(results)
+            for id, val in output.items():
+                next_paramset.update_param(id, value=val)
+
+        return (next_paramset,)
+
+class Optimize(AnalysisStep):
+    """
+    Optimize AnalysisStep: Minimizes (or maximizes) objective by optimizing opt vars
+    """
+    def __init__(self,
+            func,
+            obj_param_id = None,
+            opt_param_ids = None,
+            method = 'SLSQP',
+            ftol = None,
+            xtol = None,
+            func_output_mode = 'single',
+            condition = None
+        ):
+        super().__init__(condition)
+
+        # Validate stuff
+        # if not is_valid_kwarg_func(func): TODO make this funciton validator a thing
+        #     raise ValueError(f"Invalid Optimize: 'func' is not a valid objective function: {obj_param_id}")
+        if not isinstance(func, Callable):
+            raise ValueError(f"Invalid Optimize: 'func' is not a valid objective function: {obj_param_id}")        
+        self.func = func
+
+        if not Parameter.is_valid_id(obj_param_id):
+            raise ValueError(f"Invalid Optimize: 'obj_param_id' is not a valid param id: {obj_param_id}")
+        self.obj_param_id = obj_param_id
+
+        # TODO funcitonalize these checks so they can be onelinesrs
+        if not Parameter.is_valid_id_iterable(opt_param_ids):
+            raise ValueError(f"Invalid Optimize: 'obj_param_id' is not a valid param id tuple: {opt_param_ids}")        
+        self.opt_param_ids = opt_param_ids
+
+        self.method = method
+        self.ftol = ftol
+        self.xtol = xtol
+        self.func_output_mode = func_output_mode
+        
+    def run(self, paramset):
+        # Validate
+        super().run(paramset)
+
+        # Copy
+        next_paramset = copy.deepcopy(paramset)
+
+        # create objective wrapper where x is a list of opt vars
+        def objective_wrapper(x): # (func, next_paramset, opt_param_ids)
+            '''
+            evaluates the user supplied objective function using fresh optimizer values from x.
+            uses x to modify parameter set and then run user objective function
+            '''
+            # Create test parameter set with values from optimizer
+            test_paramset = copy.deepcopy(next_paramset)
+            test_paramset.update_param_values(dict(zip(self.opt_param_ids, x)))
+
+            # evaluate objective parameter
+            obj_val = test_paramset.call_with_matched_kwargs(self.func)
+
+            # TODO add code for different output methods
+
+            return obj_val
+        
+        # Create x0 array
+        x0 = [next_paramset[id].value for id in self.opt_param_ids]
+        
+        # run optimization
+        results = minimize(objective_wrapper, x0, method=self.method)
+
+        # Check if the number of optimization parameters matches the length of x
+        if len(self.opt_param_ids) != len(results.x):
+            raise ValueError("Number of optimization parameters does not match the length of the optimization result")
+        
+        # Set optimization parameters
+        next_paramset.update_param_values(dict(zip(self.opt_param_ids, results.x)))
+
+        # Set objective parameter
+        next_paramset.update_param(self.obj_param_id, value=results.fun)
+
+        return (next_paramset,)
+
+class End(AnalysisStep):
+    def __init__(self, condition = None):
+        super().__init__(condition)
+
+    def run(self, paramset):
+        if self.condition:
+            return None
+        else:
+            return super().run(paramset)
+
+class AnalysisModule():
+    def __init__(self, name='') -> None:
+
+        self.sequence = []
+        self.finished_leaves:int = 0
+
+        self.name = name
+
+        self.df: pd.DataFrame = pd.DataFrame()
+
+        self.t0 = None
+
+        pass
+
+    def add(self, analysis_object: AnalysisStep) -> None:
+        '''
+        appends AnalysisStep to the Analysis Sequence
+        e.g.: define, fork, evaluation or optimization
+        '''
+        # TODO Validate AnalysisStep
+
+        # TODO analysis_object.initialize(self.sequence)
+
+        self.sequence.append(analysis_object)
+
+    def run(self,
+            create_pandas = True,
+            verbose = True
+        ):
+        # self.sequence = tuple(self.sequence)
+
+        self.t0 = time()
+        self.finished_leaves = 0
+        self.execute_step(ParameterSet(), step_idx=0) # start on step 0
+
+        print('done with analysis!')
+
+        results = dict(
+            df = self.df,
+            runtime = self.runtime,
+            finished_leaves = self.finished_leaves,
+        )
+
+        return results
+
+    def execute_step(self, paramset: ParameterSet, step_idx:int):
+        """
+        Runs a single step of the analysis sequence, then recursivly calls the next.
+        """
+
+        # End analysis branch if no more steps
+        if step_idx >= len(self.sequence):
+            self.end_sequence(paramset)
+            return
+
+        # Extract step object
+        analysis_step: AnalysisStep = self.sequence[step_idx]
+
+        # Check if step has a conditional
+        run_step = True
+        if analysis_step.condition is not None:
+            run_step = paramset.call_with_matched_kwargs(analysis_step.condition)
+
+        t0 = time()
+        if run_step:
+            # Run the next step
+            new_paramsets = analysis_step.run(paramset)
+        else: # pass step
+            new_paramsets = (copy.deepcopy(paramset),)
+        step_runtime = time() - t0
+
+        # Process Step and Recursivly call next step
+        for ps in new_paramsets:
+            # Add this steps runtime to total runtime
+            ps['runtime'].value += step_runtime
+
+            # Recursivly call next step
+            self.execute_step(ps, step_idx+1)
+
+        # End analysis branch if no paramset returned
+        # TODO decide how to handle End: (paramset is None) OR (type(analysis_step)==End)
+        if new_paramsets is None:
+            self.end_sequence(paramset)
+        
+        return
+    
+    def end_sequence(self, paramset: ParameterSet):
+        # increment leaf count
+        self.finished_leaves += 1
+
+        # Add a new row to DataFrame
+        new_row = paramset.values_dict.copy()  # Copy the values_dict
+        new_row['datetime'] = datetime.now()  # Add the current datetime
+
+        # Append the new row
+        self.df = pd.concat([self.df, pd.DataFrame([new_row])], ignore_index=True)
+
+        self.runtime = time() - self.t0

functioneer-0.0.1/src/functioneer/parameter.py

@@ -0,0 +1,122 @@
+import logging
+import inspect
+
+class Parameter():
+    def __init__(self,
+            id: str,
+            value = None,
+            value_set = None, 
+            # fun = None,
+            # bounds = (None, None),
+        ):
+        
+        if isinstance(id, str) and id != '':
+            self.id = id
+        else:
+            logging.error(f"Parameter name must be a string with at least one character")
+        self.value = value
+        # self.values = values
+        # self.function = fun
+        # self.bounds = bounds
+
+    def set(self, **kwargs):
+        '''
+        set any attribute of a parameter
+        '''
+        for attr, value in kwargs.items():
+            if hasattr(self, attr):
+                setattr(self, attr, value)
+            else:
+                raise AttributeError(f"Attribute '{attr}' does not exist in the parameter.")
+            
+    @staticmethod
+    def is_valid_id(id):
+        # TODO add this to other places
+        return isinstance(id, str) and id != ''
+    
+    @staticmethod
+    def is_valid_id_iterable(id_iterable):
+        return isinstance(id_iterable, (list, tuple)) and all([Parameter.is_valid_id(id) for id in id_iterable])
+
+            
+class ParameterSet(dict):
+    def __init__(self):
+
+        self.add_param(Parameter('runtime', 0))
+
+    def add_param(self, parameter):
+        if not isinstance(parameter, Parameter):
+            raise ValueError("parameter must be an instance of Parameter")
+        
+        id = parameter.id
+
+        if id in self:
+            logging.info(f"Parameter '{id}' overwritten")
+
+        self[id] = parameter
+
+    @property
+    def values_dict(self):
+        return {key: param.value for key, param in self.items()}
+    
+    def update_param(self, id, value=None):
+        """
+        Updates attributes of parameter matching 'id' or creates a new parameter if none match
+
+        TODO add other attributes here if needed
+        """ 
+        if value is not None:
+            if id in self:
+                self[id].value = value
+            else:
+                self.add_param(Parameter(id, value))
+
+    def update_param_values(self, values_dict: dict):
+        for id, val in values_dict.items():
+            self.update_param(id, val)
+
+    # def get_value_list(self, param_ids):
+    #     # TODO Validate param_ids are in paramset
+    #     return [self[id].value for id in param_ids]
+    
+    def call_with_matched_kwargs(self, func):
+        """
+        Calls function with parameter values from the ParameterSet with matching keyword args.
+        Throws error if required arg is missing in paramset.
+        """
+        kwargs = self.values_dict
+
+        # Get the function signature
+        signature = inspect.signature(func)
+        arguments = signature.parameters
+
+        # Match provided kwargs with function arguments
+        matched_kwargs = {}
+        missing_args = []
+        for name, arg in arguments.items():
+            if name in kwargs:
+                matched_kwargs[name] = kwargs[name]
+            elif arg.default == inspect.Parameter.empty:
+                missing_args.append(name)
+
+        # Raise a warning if required arguments are missing
+        if missing_args:
+            missing_args = [f"'{arg}'" for arg in missing_args]
+            # TODO: catch this error higher up so we can provide info about WHAT param or funciton was being evaluated
+            raise ValueError(f"Missing the following required params while evaluating function: {', '.join(missing_args)}")
+
+        # Call the function with matched kwargs
+        return func(**matched_kwargs)
+
+    def call_with_positional_args(self, func, param_ids):
+        """
+        Calls function with parameter values as positional args.
+        The order of the args is the same as given in 'param_ids'.
+        """
+        # arg_list = self.get_value_list(self.input_params)
+
+        # TODO Validate param_ids are in paramset
+        arg_list = [self[id].value for id in param_ids]
+        return func(*arg_list)
+
+

functioneer-0.0.1/src/functioneer/util.py

@@ -0,0 +1,29 @@
+import inspect
+
+
+def call_with_matched_kwargs(func, kwargs):
+    '''
+    calls funciton with matching kwargs, throws error if required arg is missing.
+    TODO: could add a special case for a kwarg called kwargs where all kwargs are just fed in there. this allows user to have **kwargs on their functions
+    '''
+    # Get the function signature
+    signature = inspect.signature(func)
+    arguments = signature.parameters
+
+    # Match provided kwargs with function arguments
+    matched_kwargs = {}
+    missing_args = []
+    for name, arg in arguments.items():
+        if name in kwargs:
+            matched_kwargs[name] = kwargs[name]
+        elif arg.default == inspect.Parameter.empty:
+            missing_args.append(name)
+
+    # Raise a warning if required arguments are missing
+    if missing_args:
+        missing_args = [f"'{arg}'" for arg in missing_args]
+        # TODO: catch this error higher up so we can provide info about WHAT param or funciton was being evaluated
+        raise ValueError(f"Missing the following required params while evaluating function: {', '.join(missing_args)}")
+
+    # Call the function with matched kwargs
+    return func(**matched_kwargs)

functioneer-0.0.1/src/functioneer.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: functioneer
+Version: 0.0.1
+Summary: Functioneer is a Python package that simplifies the setup of automated analyses for your functions.
+Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
+Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
+License: Proprietary Software License
+        ----------------------------
+        
+        Software: functioneer (Functioneer)
+        Author: Quinn Marsh
+        Copyright: © [2024] Quinn Marsh
+        
+        All rights reserved.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute copies of the Software, subject to the following conditions:
+        
+        1. Attribution: All copies, substantial portions of the Software, and derivative works must include this original copyright notice, the name of the author(s), and a link to the original repository.
+        
+        2. Non-commercial Use: The Software may not be used, in whole or in part, for commercial purposes without explicit permission from the copyright holder.
+        
+        3. No Warranty: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+        4. No Misrepresentation: Users of the Software shall not misrepresent the origin of the Software and should clearly indicate any modifications made.
+        
+        By using, copying, modifying, or distributing this Software, you agree to the terms and conditions outlined above.
+        
+        
+        For details on using the Software within the terms of this license, please contact Quinn Marsh.
+        
+        Quinn Marsh
+        [quinnmarsh@hotmail.com, X @qthedoc]
+        
+Project-URL: Homepage, https://github.com/qthedoc/functioneer
+Project-URL: Issues, https://github.com/qthedoc/functioneer/issues
+Project-URL: Funding, https://donate.pypi.org
+Project-URL: Say Thanks!, http://quinnmarsh.com
+Keywords: functioneer,analysis,automation,autorun
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.18.5
+Requires-Dist: scipy>=1.5.2
+Requires-Dist: pandas>=1.0.5
+
+# Functioneer
+
+**Author**: Quinn Marsh  
+**Date**: October 21, 2024  
+
+Functioneer is a powerful Python package that simplifies the setup of automated analyses for your functions. With Functioneer, you can configure and execute functions with unlimited combinations of inputs, making it perfect for optimizations, parameter sweeps, testing, and any scenario where you need to test a function(s) over a wide range of inputs.
+
+## Features
+
+- **Fast Setup**: Define inputs, configurations, and combinations in seconds.
+- **Automated Execution**: Run functions with diverse parameter combinations, reducing repetitive setup.
+- **Flexible Input Handling**: Supports a variety of input types for complex analyses.
+- **Combinatorial Efficiency**: Specify ranges and conditions to create the full space of function possibilities.
+- **Output Management**: Easily retrieve and analyze the output of all function executions.
+
+## Installation
+
+Install Functioneer directly from PyPI:
+
+```
+pip install functioneer
+```
+
+## Documentation
+For full documentation on setting up Functioneer, customizing parameters, and handling outputs, visit the documentation site.
+
+## License
+Functioneer is released as open-source software with a custom license. Please see the LICENSE file for usage guidelines.

functioneer-0.0.1/src/functioneer.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/functioneer/__init__.py
+src/functioneer/analysis.py
+src/functioneer/parameter.py
+src/functioneer/util.py
+src/functioneer.egg-info/PKG-INFO
+src/functioneer.egg-info/SOURCES.txt
+src/functioneer.egg-info/dependency_links.txt
+src/functioneer.egg-info/requires.txt
+src/functioneer.egg-info/top_level.txt

functioneer-0.0.1/src/functioneer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

functioneer-0.0.1/src/functioneer.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.18.5
+scipy>=1.5.2
+pandas>=1.0.5

functioneer-0.0.1/src/functioneer.egg-info/top_level.txt

@@ -0,0 +1 @@
+functioneer