filter.py

import re
from tableaudocumentapi.utils import _clean_aggregated_column_names
class Filter(object):
    """A class representing a Filter in a worksheet or datasource"""
    def __init__(self, filter_xml):
        """Initialize Filter from XML Element
        
        Args:
            filter_xml: XML element representing the filter
        """
        
        self._xml = filter_xml
        self._filter_class = filter_xml.get('class')
        self._column = _clean_aggregated_column_names(filter_xml.get('column'))[1]
        self._datasource = _clean_aggregated_column_names(filter_xml.get('column'))[0]
        self._groupfilters = self._parse_groupfilters()

        self._included_values = filter_xml.get('included-values')
        self._min_value = None
        self._max_value = None
        min_el = filter_xml.find('min')
        max_el = filter_xml.find('max')
        if min_el is not None:
            self._min_value = min_el.text
        if max_el is not None:
            self._max_value = max_el.text
        
    @property
    def xml(self):
        """Return xml of the filter """
        return self._xml
    
    @property
    def groupfilters(self):
        """Return groupfilters of the filter"""
        return self._groupfilters
    
    @property
    def filter_class(self):
        """Return class attribute of the filter""" 
        return self._filter_class
    
    @property
    def column(self):
        """Return columns of the filter """
        return self._column
    
    @property
    def datasource(self):
        """Return datasource of the columns of the filter """
        return self._datasource

    @property
    def min_value(self):
        """Return <min> text for quantitative range filters, or None."""
        return self._min_value

    @property
    def max_value(self):
        """Return <max> text for quantitative range filters, or None."""
        return self._max_value

    @property
    def included_values(self):
        """Return the included-values attribute (e.g. 'in-range', 'all'), or None."""
        return self._included_values

    @property
    def members(self):
        """Flat list of member values extracted from groupfilters (categorical filters)."""
        values = []

        def _extract(gf_list):
            for gf in gf_list:
                if gf.get('function') == 'member' and gf.get('member'):
                    values.append(gf['member'].strip('"'))
                _extract(gf.get('children', []))

        _extract(self._groupfilters)
        return values

    def _parse_groupfilters(self):
        """Function that will parse the groupfilters under the filter"""
        groupfilters = []
        groupfilter_elements = self._xml.findall('groupfilter')
        for groupfilter in groupfilter_elements:
            parsed_groupfilter = self._parse_single_groupfilter(groupfilter)
            if parsed_groupfilter:
                groupfilters.append(parsed_groupfilter)
        return groupfilters
    
    def _parse_single_groupfilter(self, groupfilter_xml):
        """Parse a single groupfilter element recursively"""
        if groupfilter_xml is None:
            return None
            
        groupfilter_data = {
            'function': groupfilter_xml.get('function'),
            'level': groupfilter_xml.get('level'),
            'member': groupfilter_xml.get('member'),
            'attributes': dict(groupfilter_xml.attrib),
            'children': []
        }
        
        # Parse nested groupfilters recursively
        child_groupfilters = groupfilter_xml.findall('groupfilter')
        for child in child_groupfilters:
            child_data = self._parse_single_groupfilter(child)
            if child_data:
                groupfilter_data['children'].append(child_data)
                
        return groupfilter_data
    
def _parse_filters(root_node, path):
    """Function that will parse the filters under the worksheet or datasource"""
    filters = []
    filter_elements = root_node.findall(path)
    for filter_element in filter_elements:
        filters.append(Filter(filter_element))
    return filters