LSST Applications g0b6bd0c080+a72a5dd7e6,g1182afd7b4+2a019aa3bb,g17e5ecfddb+2b8207f7de,g1d67935e3f+06cf436103,g38293774b4+ac198e9f13,g396055baef+6a2097e274,g3b44f30a73+6611e0205b,g480783c3b1+98f8679e14,g48ccf36440+89c08d0516,g4b93dc025c+98f8679e14,g5c4744a4d9+a302e8c7f0,g613e996a0d+e1c447f2e0,g6c8d09e9e7+25247a063c,g7271f0639c+98f8679e14,g7a9cd813b8+124095ede6,g9d27549199+a302e8c7f0,ga1cf026fa3+ac198e9f13,ga32aa97882+7403ac30ac,ga786bb30fb+7a139211af,gaa63f70f4e+9994eb9896,gabf319e997+ade567573c,gba47b54d5d+94dc90c3ea,gbec6a3398f+06cf436103,gc6308e37c7+07dd123edb,gc655b1545f+ade567573c,gcc9029db3c+ab229f5caf,gd01420fc67+06cf436103,gd877ba84e5+06cf436103,gdb4cecd868+6f279b5b48,ge2d134c3d5+cc4dbb2e3f,ge448b5faa6+86d1ceac1d,gecc7e12556+98f8679e14,gf3ee170dca+25247a063c,gf4ac96e456+ade567573c,gf9f5ea5b4d+ac198e9f13,gff490e6085+8c2580be5c,w.2022.27
LSST Data Management Base Package
_evalColumnExpression.py
Go to the documentation of this file.
1# This file is part of pipe_tasks.
2#
3# Developed for the LSST Data Management System.
4# This product includes software developed by the LSST Project
5# (https://www.lsst.org).
6# See the COPYRIGHT file at the top-level directory of this distribution
7# for details of code ownership.
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 3 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program. If not, see <https://www.gnu.org/licenses/>.
21
22from __future__ import annotations
23
24__all__ = ("makeColumnExpressionAction", )
25
26import ast
27import operator as op
28
29from typing import Mapping, MutableMapping, Set, Type, Union, Optional, Any, Iterable
30
31from numpy import log10 as log
32from numpy import (cos, sin, cosh, sinh)
33import pandas as pd
34
35from ..configurableActions import ConfigurableActionField
36from ._baseDataFrameActions import DataFrameAction
37
38
39OPERATORS = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
40 ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor,
41 ast.USub: op.neg}
42
43EXTRA_MATH = {"cos": cos, "sin": sin, "cosh": cosh, "sinh": sinh, "log": log}
44
45
46class ExpressionParser(ast.NodeVisitor):
47 def __init__(self, **kwargs):
48 self.variablesvariables = kwargs
49 self.variablesvariables['log'] = log
50
51 def visit_Name(self, node):
52 if node.id in self.variablesvariables:
53 return self.variablesvariables[node.id]
54 else:
55 return None
56
57 def visit_Num(self, node):
58 return node.n
59
60 def visit_NameConstant(self, node):
61 return node.value
62
63 def visit_UnaryOp(self, node):
64 val = self.visit(node.operand)
65 return OPERATORS[type(node.op)](val)
66
67 def visit_BinOp(self, node):
68 lhs = self.visit(node.left)
69 rhs = self.visit(node.right)
70 return OPERATORS[type(node.op)](lhs, rhs)
71
72 def visit_Call(self, node):
73 if node.func.id in self.variablesvariables:
74 function = self.visit(node.func)
75 return function(self.visit(node.args[0]))
76 else:
77 raise ValueError("String not recognized")
78
79 def generic_visit(self, node):
80 raise ValueError("String not recognized")
81
82
83def makeColumnExpressionAction(className: str, expr: str,
84 exprDefaults: Optional[Mapping[str, Union[DataFrameAction,
85 Type[DataFrameAction]]]] = None,
86 docstring: str = None
87 ) -> Type[DataFrameAction]:
88 """Factory function for producing ConfigurableAction classes which are
89 realizations of arithmetic operations.
90
91 Parameters
92 ----------
93 className : `str`
94 The name of the class that will be produced
95 expr : `str`
96 An arithmetic expression that will be parsed to produce the output
97 ConfigurableAction. Individual variable names will be the name of
98 individual `ConfigActions` inside the expression (i.e. "x+y" will
99 produce an action with configAction.actions.x and
100 configAction.actions.y). Expression can contain arithmatic python
101 operators as well as; sin, cos, sinh, cosh, log (which is base 10).
102 exprDefaults : `Mapping` of `str` to `DataFrameAction` optional
103 A mapping of strings which correspond to the names in the expression to
104 values which are default `ConfigurableActions` to assign in the
105 expression. If no default for a action is supplied `SingleColumnAction`
106 is set as the default.
107 docstring : `str`
108 A string that is assigned as the resulting classes docstring
109
110 Returns
111 -------
112 action : `Type` of `DataFrameAction`
113 A `DataFrameAction` class that was programatically constructed from the
114 input expression.
115 """
116 # inspect is used because this is a factory function used to produce classes
117 # and it is desireable that the classes generated appear to be in the
118 # module of the calling frame, instead of something defined within the
119 # scope of this function call.
120 import inspect
121 new_module = inspect.stack()[1].frame.f_locals['__name__']
122 node = ast.parse(expr, mode='eval')
123
124 # gather the specified names
125 names: Set[str] = set()
126 for elm in ast.walk(node):
127 if isinstance(elm, ast.Name):
128 names.add(elm.id)
129
130 # remove the known Math names
131 names -= EXTRA_MATH.keys()
132
133 fields: Mapping[str, ConfigurableActionField] = {}
134 for name in names:
135 if exprDefaults is not None and (value := exprDefaults.get(name)) is not None:
136 kwargs = {"default": value}
137 else:
138 kwargs = {}
139 fields[name] = ConfigurableActionField(doc=f"expression action {name}", **kwargs)
140
141 # skip flake8 on N807 because this is a stand alone function, but it is
142 # intended to be patched in as a method on a dynamically generated class
143 def __call__(self, df: pd.DataFrame, **kwargs) -> pd.Series: # noqa: N807
144 values_map = {}
145 for name in fields:
146 values_map[name] = getattr(self, name)(df, **kwargs)
147
148 parser = ExpressionParser(**values_map)
149 return parser.visit(node.body)
150
151 # create the function to look up the columns for the dynamically created action
152 def columns(self) -> Iterable[str]:
153 for name in fields:
154 yield from getattr(self, name).columns
155
156 dct: MutableMapping[str, Any] = {"__call__": __call__, "columns": property(columns)}
157 if docstring is not None:
158 dct['__doc__'] = docstring
159 dct.update(**fields)
160 dct['__module__'] = new_module
161
162 return type(className, (DataFrameAction, ), dct)
table::Key< int > type
Definition: Detector.cc:163
table::Key< int > from
daf::base::PropertySet * set
Definition: fits.cc:912
Type[DataFrameAction] makeColumnExpressionAction(str className, str expr, Optional[Mapping[str, Union[DataFrameAction, Type[DataFrameAction]]]] exprDefaults=None, str docstring=None)