Method _required_expr_vars

tables/table.py:1239–1352

Get the variables required by the `expression`. A new dictionary defining the variables used in the `expression` is returned. Required variables are first looked up in the `uservars` mapping, then in the set of top-level columns of the table. Unknown variables caus

(
        self,
        expression: str,
        uservars: dict[str, Column | np.ndarray] | None,
        depth: int = 1,
    )

        self._enabled_indexing_in_queries = True

    def _required_expr_vars(
        self,
        expression: str,
        uservars: dict[str, Column | np.ndarray] | None,
        depth: int = 1,
    ) -> dict[str, Column | np.ndarray]:
        """Get the variables required by the `expression`.

        A new dictionary defining the variables used in the `expression`
        is returned.  Required variables are first looked up in the
        `uservars` mapping, then in the set of top-level columns of the
        table.  Unknown variables cause a `NameError` to be raised.

        When `uservars` is `None`, the local and global namespace where
        the API callable which uses this method is called is sought
        instead.  This mechanism will not work as expected if this
        method is not used *directly* from an API callable.  To disable
        this mechanism, just specify a mapping as `uservars`.

        Nested columns and columns from other tables are not allowed
        (`TypeError` and `ValueError` are raised, respectively).  Also,
        non-column variable values are converted to NumPy arrays.

        `depth` specifies the depth of the frame in order to reach local
        or global variables.

        """
        # Get the names of variables used in the expression.
        exprvarscache = self._exprvars_cache
        if expression not in exprvarscache:
            # Protection against growing the cache too much
            if len(exprvarscache) > 256:
                # Remove 10 (arbitrary) elements from the cache
                for k in list(exprvarscache)[:10]:
                    del exprvarscache[k]
            cexpr = compile(expression, "<string>", "eval")
            exprvars = [
                var
                for var in cexpr.co_names
                if var not in ["None", "False", "True"]
                and var not in ne.expressions.functions
            ]
            exprvarscache[expression] = exprvars
        else:
            exprvars = exprvarscache[expression]

        # Get the local and global variable mappings of the user frame
        # if no mapping has been explicitly given for user variables.
        user_locals, user_globals = {}, {}
        if uservars is None:
            # We use specified depth to get the frame where the API
            # callable using this method is called.  For instance:
            #
            # * ``table._required_expr_vars()`` (depth 0) is called by
            # * ``table._where()`` (depth 1) is called by
            # * ``table.where()`` (depth 2) is called by
            # * user-space functions (depth 3)
            user_frame = sys._getframe(depth)