Subset

AnonymousSubset(dimension_name, hierarchy_name=None, expression=None, elements=None, alias='')

Bases: Subset

Abstraction of unregistered Subsets used in NativeViews (Check TM1py.ViewAxisSelection)

Source code in TM1py/Objects/Subset.py

def __init__(
    self,
    dimension_name: str,
    hierarchy_name: Optional[str] = None,
    expression: Optional[str] = None,
    elements: Optional[Iterable[str]] = None,
    alias: str = "",
):
    Subset.__init__(
        self,
        dimension_name=dimension_name,
        hierarchy_name=hierarchy_name if hierarchy_name else dimension_name,
        subset_name="",
        alias=alias,
        expression=expression,
        elements=elements,
    )

from_dict(subset_as_dict) classmethod

Alternative constructor

Parameters:

Name	Type	Description	Default
subset_as_dict	Dict	dictionary, representation of Subset as specified in CSDL	required

Returns:

Type	Description
Subset	an instance of this class

Source code in TM1py/Objects/Subset.py

@classmethod
def from_dict(cls, subset_as_dict: Dict) -> "Subset":
    """Alternative constructor

    :param subset_as_dict: dictionary, representation of Subset as specified in CSDL
    :return: an instance of this class
    """
    if "Hierarchy" in subset_as_dict:
        dimension_name = subset_as_dict["Hierarchy"]["Dimension"]["Name"]
        hierarchy_name = subset_as_dict["Hierarchy"]["Name"]

    elif "Hierarchy@odata.bind" in subset_as_dict:
        hierarchy_odata = subset_as_dict["Hierarchy@odata.bind"]

        dimension_name = read_object_name_from_url(
            url=hierarchy_odata, pattern=r"Dimensions\('(.*?)'\)/Hierarchies\('(.+?)'\)"
        )

        hierarchy_name = read_object_name_from_url(
            url=hierarchy_odata, pattern=r"Dimensions\('(.+?)'\)/Hierarchies\('(.*?)'\)"
        )

        if not all([dimension_name, hierarchy_name]):
            raise ValueError(
                f"Unexpected value for 'Hierarchy@odata.bind' property in subset dict: '{hierarchy_odata}'"
            )

    else:
        raise ValueError("Subset dict must contain 'Hierarchy' or 'Hierarchy@odata.bind' as key")

    if "Elements" in subset_as_dict:
        elements = [element["Name"] for element in subset_as_dict["Elements"]]
    elif "Elements@odata.bind" in subset_as_dict:
        elements = list()

        elements_odata = subset_as_dict["Elements@odata.bind"]
        pattern = r"Dimensions\('.*?'\)/Hierarchies\('.*?'\)/Elements\('(.+?)'\)"
        for element_odata in elements_odata:
            element = read_object_name_from_url(element_odata, pattern)
            if not element:
                raise ValueError(
                    f"Unexpected entry '{element_odata}' for 'Elements@odata.bind' property in subset dict"
                )

            elements.append(element)
    else:
        elements = None

    return cls(
        dimension_name=dimension_name,
        hierarchy_name=hierarchy_name,
        expression=subset_as_dict.get("Expression", None),
        alias=subset_as_dict.get("Alias", None),
        elements=elements if not subset_as_dict.get("Expression", None) else None,
    )

from_json(subset_as_json) classmethod

Alternative constructor :Parameters: subset_as_json : string, JSON representation of Subset as specified in CSDL

:Returns: Subset : an instance of this class

Source code in TM1py/Objects/Subset.py

@classmethod
def from_json(cls, subset_as_json: str) -> "Subset":
    """Alternative constructor
    :Parameters:
        `subset_as_json` : string, JSON
            representation of Subset as specified in CSDL

    :Returns:
        `Subset` : an instance of this class
    """
    subset_as_dict = json.loads(subset_as_json)
    return cls.from_dict(subset_as_dict=subset_as_dict)

Subset(subset_name, dimension_name, hierarchy_name=None, alias=None, expression=None, elements=None)

Bases: TM1Object

Abstraction of the TM1 Subset (dynamic and static)

Parameters:

Name	Type	Description	Default
subset_name	str	String	required
dimension_name	str	String	required
hierarchy_name	str	String	None
alias	str	String, alias that is active in this subset.	None
expression	str	String	None
elements	Iterable[str]	List, element names	None

Source code in TM1py/Objects/Subset.py

def __init__(
    self,
    subset_name: str,
    dimension_name: str,
    hierarchy_name: str = None,
    alias: str = None,
    expression: str = None,
    elements: Iterable[str] = None,
):
    """

    :param subset_name: String
    :param dimension_name: String
    :param hierarchy_name: String
    :param alias: String, alias that is active in this subset.
    :param expression: String
    :param elements: List, element names
    """
    self._dimension_name = dimension_name
    self._hierarchy_name = hierarchy_name if hierarchy_name else dimension_name
    self._subset_name = subset_name
    self._alias = alias
    self._expression = expression
    self._elements = list(elements) if elements else []

alias property writable

body property

same logic here as in TM1 : when subset has expression its dynamic, otherwise static

body_as_dict property

same logic here as in TM1 : when subset has expression its dynamic, otherwise static

dimension_name property writable

elements property writable

expression property writable

hierarchy_name property writable

is_dynamic property

is_static property

name property writable

type property

add_elements(elements)

add Elements to static subsets :Parameters: elements : list of element names

Source code in TM1py/Objects/Subset.py

def add_elements(self, elements: Iterable[str]):
    """add Elements to static subsets
    :Parameters:
        `elements` : list of element names
    """
    self._elements = self._elements + list(elements)

from_dict(subset_as_dict) classmethod

Source code in TM1py/Objects/Subset.py

@classmethod
def from_dict(cls, subset_as_dict: Dict) -> "Subset":
    return cls(
        dimension_name=subset_as_dict["UniqueName"][1 : subset_as_dict["UniqueName"].find("].[")],
        hierarchy_name=subset_as_dict.get("Hierarchy", {}).get("Name"),
        subset_name=subset_as_dict["Name"],
        alias=subset_as_dict.get("Alias"),
        expression=subset_as_dict.get("Expression"),
        elements=(
            [element["Name"] for element in subset_as_dict.get("Elements", [])]
            if not subset_as_dict.get("Expression")
            else None
        ),
    )

from_json(subset_as_json) classmethod

Alternative constructor :Parameters: subset_as_json : string, JSON representation of Subset as specified in CSDL

:Returns: Subset : an instance of this class

Source code in TM1py/Objects/Subset.py

@classmethod
def from_json(cls, subset_as_json: str) -> "Subset":
    """Alternative constructor
    :Parameters:
        `subset_as_json` : string, JSON
            representation of Subset as specified in CSDL

    :Returns:
        `Subset` : an instance of this class
    """

    subset_as_dict = json.loads(subset_as_json)
    return cls.from_dict(subset_as_dict=subset_as_dict)