TM1py 2.2.1__py3-none-any.whl

TM1py/Objects/Axis.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+
+import collections
+import json
+from typing import Dict, Union
+
+from TM1py.Objects.Subset import AnonymousSubset, Subset
+from TM1py.Objects.TM1Object import TM1Object
+from TM1py.Utils import format_url
+
+
+class ViewAxisSelection(TM1Object):
+    """Describes what is selected in a dimension on an axis. Can be a Registered Subset or an Anonymous Subset"""
+
+    def __init__(self, dimension_name: str, subset: Union[Subset, AnonymousSubset]):
+        """
+        :Parameters:
+            `dimension_name` : String
+            `subset` : Subset or AnonymousSubset
+        """
+        self._subset = subset
+        self._dimension_name = dimension_name
+        self._hierarchy_name = dimension_name
+
+    @property
+    def subset(self) -> Union[Subset, AnonymousSubset]:
+        return self._subset
+
+    @property
+    def dimension_name(self) -> str:
+        return self._dimension_name
+
+    @property
+    def hierarchy_name(self) -> str:
+        return self._hierarchy_name
+
+    @property
+    def body(self) -> str:
+        return json.dumps(self._construct_body(), ensure_ascii=False)
+
+    @property
+    def body_as_dict(self) -> Dict:
+        return self._construct_body()
+
+    def _construct_body(self) -> Dict:
+        """construct the ODATA conform JSON represenation for the ViewAxisSelection entity.
+
+        :return: dictionary
+        """
+        body_as_dict = collections.OrderedDict()
+        if isinstance(self._subset, AnonymousSubset):
+            body_as_dict["Subset"] = json.loads(self._subset.body)
+        elif isinstance(self._subset, Subset):
+            subset_path = format_url(
+                "Dimensions('{}')/Hierarchies('{}')/Subsets('{}')",
+                self._dimension_name,
+                self._hierarchy_name,
+                self._subset.name,
+            )
+            body_as_dict["Subset@odata.bind"] = subset_path
+        return body_as_dict
+
+
+class ViewTitleSelection:
+    """Describes what is selected in a dimension on the view title.
+    Can be a Registered Subset or an Anonymous Subset
+
+    """
+
+    def __init__(self, dimension_name: str, subset: Union[AnonymousSubset, Subset], selected: str):
+        self._dimension_name = dimension_name
+        self._hierarchy_name = dimension_name
+        self._subset = subset
+        self._selected = selected
+
+    @property
+    def subset(self) -> Union[Subset, AnonymousSubset]:
+        return self._subset
+
+    @property
+    def dimension_name(self) -> str:
+        return self._dimension_name
+
+    @property
+    def hierarchy_name(self) -> str:
+        return self._hierarchy_name
+
+    @property
+    def selected(self) -> str:
+        return self._selected
+
+    @property
+    def body(self) -> str:
+        return json.dumps(self._construct_body(), ensure_ascii=False)
+
+    def _construct_body(self) -> Dict:
+        """construct the ODATA conform JSON represenation for the ViewTitleSelection entity.
+
+        :return: string, the valid JSON
+        """
+        body_as_dict = collections.OrderedDict()
+        if isinstance(self._subset, AnonymousSubset):
+            body_as_dict["Subset"] = json.loads(self._subset.body)
+        elif isinstance(self._subset, Subset):
+            subset_path = format_url(
+                "Dimensions('{}')/Hierarchies('{}')/Subsets('{}')",
+                self._dimension_name,
+                self._hierarchy_name,
+                self._subset.name,
+            )
+            body_as_dict["Subset@odata.bind"] = subset_path
+        element_path = format_url(
+            "Dimensions('{}')/Hierarchies('{}')/Elements('{}')",
+            self._dimension_name,
+            self._hierarchy_name,
+            self._selected,
+        )
+        body_as_dict["Selected@odata.bind"] = element_path
+        return body_as_dict

TM1py/Objects/Chore.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+import collections
+import json
+from typing import Dict, Iterable, List
+
+from TM1py.Objects.ChoreFrequency import ChoreFrequency
+from TM1py.Objects.ChoreStartTime import ChoreStartTime
+from TM1py.Objects.ChoreTask import ChoreTask
+from TM1py.Objects.TM1Object import TM1Object
+
+
+class Chore(TM1Object):
+    """Abstraction of TM1 Chore"""
+
+    SINGLE_COMMIT = "SingleCommit"
+    MULTIPLE_COMMIT = "MultipleCommit"
+
+    def __init__(
+        self,
+        name: str,
+        start_time: ChoreStartTime,
+        dst_sensitivity: bool,
+        active: bool,
+        execution_mode: str,
+        frequency: ChoreFrequency,
+        tasks: Iterable[ChoreTask],
+    ):
+        self._name = name
+        self._start_time = start_time
+        self._dst_sensitivity = dst_sensitivity
+        self._active = active
+        self._execution_mode = execution_mode
+        self._frequency = frequency
+        self._tasks = list(tasks)
+
+    @classmethod
+    def from_json(cls, chore_as_json: str) -> "Chore":
+        """Alternative constructor
+
+        :param chore_as_json: string, JSON. Response of /Chores('x')/Tasks?$expand=*
+        :return: Chore, an instance of this class
+        """
+        chore_as_dict = json.loads(chore_as_json)
+        return cls.from_dict(chore_as_dict)
+
+    @classmethod
+    def from_dict(cls, chore_as_dict: Dict) -> "Chore":
+        """Alternative constructor
+
+        :param chore_as_dict: Chore as dict
+        :return: Chore, an instance of this class
+        """
+        return cls(
+            name=chore_as_dict["Name"],
+            start_time=ChoreStartTime.from_string(chore_as_dict["StartTime"]),
+            dst_sensitivity=chore_as_dict["DSTSensitive"],
+            active=chore_as_dict["Active"],
+            execution_mode=chore_as_dict["ExecutionMode"],
+            frequency=ChoreFrequency.from_string(chore_as_dict["Frequency"]),
+            tasks=[ChoreTask.from_dict(task, step) for step, task in enumerate(chore_as_dict["Tasks"])],
+        )
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, name: str):
+        self._name = name
+
+    @property
+    def start_time(self) -> ChoreStartTime:
+        return self._start_time
+
+    @start_time.setter
+    def start_time(self, start_time: ChoreStartTime):
+        self._start_time = start_time
+
+    @property
+    def dst_sensitivity(self) -> bool:
+        return self._dst_sensitivity
+
+    @dst_sensitivity.setter
+    def dst_sensitivity(self, dst_sensitivity: bool):
+        self._dst_sensitivity = dst_sensitivity
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @property
+    def execution_mode(self) -> str:
+        return self._execution_mode
+
+    @execution_mode.setter
+    def execution_mode(self, execution_mode):
+        self._execution_mode = execution_mode
+
+    @property
+    def frequency(self) -> ChoreFrequency:
+        return self._frequency
+
+    @frequency.setter
+    def frequency(self, frequency: ChoreFrequency):
+        self._frequency = frequency
+
+    @property
+    def tasks(self) -> List[ChoreTask]:
+        return self._tasks
+
+    @tasks.setter
+    def tasks(self, tasks: List[ChoreTask]):
+        self._tasks = tasks
+
+    @property
+    def body(self) -> str:
+        return self.construct_body()
+
+    @property
+    def body_as_dict(self) -> Dict:
+        return json.loads(self.body)
+
+    @property
+    def execution_path(self) -> Dict:
+        """
+        1 chore together with its executed processes
+        Use case: building out a tree of chores and their processes (and again the processes that are called by the latter (if any)).
+        :return: dictionary containing chore name as the key and a list of process names as the value
+        """
+        return {self.name: [task.process_name for task in self.tasks]}
+
+    def add_task(self, task: ChoreTask):
+        self._tasks.append(task)
+
+    def insert_task(self, new_task: ChoreTask):
+        task_list = self.tasks
+        for task in task_list[new_task._step :]:
+            task._step = task._step + 1
+        task_list.insert(new_task._step, new_task)
+        self.tasks = task_list
+
+    def activate(self):
+        self._active = True
+
+    def deactivate(self):
+        self._active = False
+
+    def reschedule(self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0):
+        self._start_time.add(days=days, hours=hours, minutes=minutes, seconds=seconds)
+
+    def construct_body(self) -> str:
+        """
+        construct self.body (json) from the class attributes
+        :return: String, TM1 JSON representation of a chore
+        """
+        body_as_dict = collections.OrderedDict()
+        body_as_dict["Name"] = self._name
+        body_as_dict["StartTime"] = self._start_time.start_time_string
+        body_as_dict["DSTSensitive"] = self._dst_sensitivity
+        body_as_dict["Active"] = self._active
+        body_as_dict["ExecutionMode"] = self._execution_mode
+        body_as_dict["Frequency"] = self._frequency.frequency_string
+        body_as_dict["Tasks"] = [task.body_as_dict for task in self._tasks]
+        return json.dumps(body_as_dict, ensure_ascii=False)

TM1py/Objects/ChoreFrequency.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+from typing import Union
+
+from TM1py.Objects.TM1Object import TM1Object
+
+
+class ChoreFrequency(TM1Object):
+    """Utility class to handle time representation fore Chore Frequency"""
+
+    def __init__(
+        self, days: Union[str, int], hours: Union[str, int], minutes: Union[str, int], seconds: Union[str, int]
+    ):
+        self._days = str(days).zfill(2)
+        self._hours = str(hours).zfill(2)
+        self._minutes = str(minutes).zfill(2)
+        self._seconds = str(seconds).zfill(2)
+
+    @property
+    def days(self) -> str:
+        return self._days
+
+    @property
+    def hours(self) -> str:
+        return self._hours
+
+    @property
+    def minutes(self) -> str:
+        return self._minutes
+
+    @property
+    def seconds(self) -> str:
+        return self._seconds
+
+    @days.setter
+    def days(self, value: Union[str, int]):
+        self._days = str(value).zfill(2)
+
+    @hours.setter
+    def hours(self, value: Union[str, int]):
+        self._hours = str(value).zfill(2)
+
+    @minutes.setter
+    def minutes(self, value: Union[str, int]):
+        self._minutes = str(value).zfill(2)
+
+    @seconds.setter
+    def seconds(self, value: Union[str, int]):
+        self._seconds = str(value).zfill(2)
+
+    @classmethod
+    def from_string(cls, frequency_string: str) -> "ChoreFrequency":
+        pos_dt = frequency_string.find("DT", 1)
+        pos_h = frequency_string.find("H", pos_dt)
+        pos_m = frequency_string.find("M", pos_h)
+        pos_s = len(frequency_string) - 1
+        return cls(
+            days=frequency_string[1:pos_dt],
+            hours=frequency_string[pos_dt + 2 : pos_h],
+            minutes=frequency_string[pos_h + 1 : pos_m],
+            seconds=frequency_string[pos_m + 1 : pos_s],
+        )
+
+    @property
+    def frequency_string(self) -> str:
+        return "P{}DT{}H{}M{}S".format(self._days, self._hours, self._minutes, self._seconds)
+
+    def __str__(self) -> str:
+        return self.frequency_string

TM1py/Objects/ChoreStartTime.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+
+
+class ChoreStartTime:
+    """Utility class to handle time representation for Chore Start Time"""
+
+    def __init__(self, year: int, month: int, day: int, hour: int, minute: int, second: int, tz: str = None):
+        """
+
+        :param year: year
+        :param month: month
+        :param day: day
+        :param hour: hour or None
+        :param minute: minute or None
+        :param second: second or None
+        """
+        self._datetime = datetime.datetime.combine(datetime.date(year, month, day), datetime.time(hour, minute, second))
+        self.tz = tz
+
+    @classmethod
+    def from_string(cls, start_time_string: str) -> "ChoreStartTime":
+        # extract optional tz info (e.g., +01:00) from string end
+        if "+" in start_time_string:
+            # case "2020-11-05T08:00:01+01:00",
+            tz = "+" + start_time_string.split("+")[1]
+        elif start_time_string.count("-") == 3:
+            # case: "2020-11-05T08:00:01-01:00",
+            tz = "-" + start_time_string.split("-")[-1]
+        else:
+            tz = None
+
+        # f to handle strange timestamp 2016-09-25T20:25Z instead of common 2016-09-25T20:25:00Z
+        # second is defaulted to 0 if not specified in the chore schedule
+        def format_time(value: int) -> str:
+            return int(value or 0)
+
+        return cls(
+            year=format_time(start_time_string[0:4]),
+            month=format_time(start_time_string[5:7]),
+            day=format_time(start_time_string[8:10]),
+            hour=format_time(start_time_string[11:13]),
+            minute=format_time(start_time_string[14:16]),
+            second=format_time(0 if start_time_string[16] != ":" else start_time_string[17:19]),
+            tz=tz,
+        )
+
+    @property
+    def start_time_string(self) -> str:
+        # produce timestamp 2016-09-25T20:25:00Z instead of common 2016-09-25T20:25Z where no seconds are specified
+        start_time = self._datetime.strftime("%Y-%m-%dT%H:%M:%S")
+
+        if self.tz:
+            start_time += self.tz
+        else:
+            start_time += "Z"
+
+        return start_time
+
+    @property
+    def datetime(self) -> datetime:
+        return self._datetime
+
+    def __str__(self):
+        return self.start_time_string
+
+    def set_time(
+        self,
+        year: int = None,
+        month: int = None,
+        day: int = None,
+        hour: int = None,
+        minute: int = None,
+        second: int = None,
+    ):
+
+        _year = year if year is not None else self._datetime.year
+        _month = month if month is not None else self._datetime.month
+        _day = day if day is not None else self._datetime.day
+        _hour = hour if hour is not None else self._datetime.hour
+        _minute = minute if minute is not None else self._datetime.minute
+        _second = second if second is not None else self._datetime.second
+
+        self._datetime = self._datetime.replace(
+            year=_year, month=_month, day=_day, hour=_hour, minute=_minute, second=_second
+        )
+
+    def add(self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0):
+        self._datetime = self._datetime + datetime.timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)
+
+    def subtract(self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0):
+        self._datetime = self._datetime - datetime.timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)

TM1py/Objects/ChoreTask.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+import collections
+import json
+from typing import Dict, List
+
+from TM1py.Objects.TM1Object import TM1Object
+from TM1py.Utils import format_url
+
+
+class ChoreTask(TM1Object):
+    """Abstraction of a Chore Task
+
+    A Chore task always conistst of
+    - The step integer ID: it's order in the execution plan.
+      1 to n, where n is the last Process in the Chore
+    - The name of the process to execute
+    - The parameters for the process
+
+    """
+
+    def __init__(self, step: int, process_name: str, parameters: List[Dict[str, str]]):
+        """
+
+        :param step: step in the execution order of the Chores' processes. 1 to n, where n the number of processes
+        :param process_name: name of the process
+        :param parameters: list of dictionaries with 'Name' and 'Value' property:
+                            [{
+                                'Name': '..',
+                                'Value': '..'
+                            },
+                            ...
+                            ]
+        """
+        self._step = step
+        self._process_name = process_name
+        self._parameters = parameters
+
+    @classmethod
+    def from_dict(cls, chore_task_as_dict: Dict, step: int = None):
+        if "Process" in chore_task_as_dict:
+            process_name = chore_task_as_dict["Process"]["Name"]
+        else:
+            # Extract "ProcessName" from "Processes('ProcessName')"
+            process_name = chore_task_as_dict["Process@odata.bind"][11:-2]
+
+        return cls(
+            step=step if step is not None else int(chore_task_as_dict["Step"]),
+            process_name=process_name,
+            parameters=[{"Name": p["Name"], "Value": p["Value"]} for p in chore_task_as_dict["Parameters"]],
+        )
+
+    @property
+    def body_as_dict(self) -> Dict:
+        body_as_dict = collections.OrderedDict()
+        body_as_dict["Process@odata.bind"] = format_url("Processes('{}')", self._process_name)
+        body_as_dict["Parameters"] = self._parameters
+        return body_as_dict
+
+    @property
+    def step(self) -> int:
+        return self._step
+
+    @property
+    def process_name(self) -> str:
+        return self._process_name
+
+    @property
+    def parameters(self) -> List[Dict[str, str]]:
+        return self._parameters
+
+    @property
+    def body(self) -> str:
+        return json.dumps(self.body_as_dict, ensure_ascii=False)
+
+    def __eq__(self, other: "ChoreTask") -> bool:
+        return self.process_name == other.process_name and self.parameters == other.parameters
+
+    def __ne__(self, other: "ChoreTask") -> bool:
+        return self.process_name != other.process_name or self._parameters != other.parameters

TM1py/Objects/Cube.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+import collections
+import json
+from typing import Dict, Iterable, List, Optional, Union
+
+from TM1py.Objects.Rules import Rules
+from TM1py.Objects.TM1Object import TM1Object
+from TM1py.Utils import format_url
+
+
+class Cube(TM1Object):
+    """Abstraction of a TM1 Cube"""
+
+    def __init__(self, name: str, dimensions: Iterable[str], rules: Optional[Union[str, Rules]] = None):
+        """
+
+        :param name: name of the Cube
+        :param dimensions: list of (existing) dimension names
+        :param rules: instance of TM1py.Objects.Rules
+        """
+        self._name = name
+        self.dimensions = list(dimensions)
+        self.rules = rules
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def dimensions(self) -> List[str]:
+        return self._dimensions
+
+    @dimensions.setter
+    def dimensions(self, value: List[str]):
+        self._dimensions = value
+
+    @property
+    def has_rules(self) -> bool:
+        if self._rules:
+            return True
+        return False
+
+    @property
+    def rules(self) -> Rules:
+        return self._rules
+
+    @rules.setter
+    def rules(self, value: Union[str, Rules]):
+        if value is None:
+            self._rules = None
+        elif isinstance(value, str):
+            self._rules = Rules(rules=value)
+        elif isinstance(value, Rules):
+            self._rules = value
+        else:
+            raise ValueError("value must None or of type str or Rules")
+
+    @property
+    def skipcheck(self) -> bool:
+        if self.has_rules:
+            return self.rules.skipcheck
+        return False
+
+    @property
+    def undefvals(self) -> bool:
+        if self.has_rules:
+            return self.rules.undefvals
+        return False
+
+    @property
+    def feedstrings(self) -> bool:
+        if self.has_rules:
+            return self.rules.feedstrings
+        return False
+
+    @classmethod
+    def from_json(cls, cube_as_json: str) -> "Cube":
+        """Alternative constructor
+
+        :param cube_as_json: user as JSON string
+        :return: cube, an instance of this class
+        """
+        cube_as_dict = json.loads(cube_as_json)
+        return cls.from_dict(cube_as_dict)
+
+    @classmethod
+    def from_dict(cls, cube_as_dict: Dict) -> "Cube":
+        """Alternative constructor
+
+        :param cube_as_dict: user as dict
+        :return: user, an instance of this class
+        """
+        return cls(
+            name=cube_as_dict["Name"],
+            dimensions=[dimension["Name"] for dimension in cube_as_dict["Dimensions"]],
+            rules=Rules(cube_as_dict["Rules"]) if cube_as_dict["Rules"] else None,
+        )
+
+    @property
+    def body(self) -> str:
+        return self._construct_body()
+
+    def _construct_body(self) -> str:
+        """
+        construct body (json) from the class attributes
+        :return: String, TM1 JSON representation of a cube
+        """
+        body_as_dict = collections.OrderedDict()
+        body_as_dict["Name"] = self.name
+        body_as_dict["Dimensions@odata.bind"] = [
+            format_url("Dimensions('{}')", dimension) for dimension in self.dimensions
+        ]
+        if self.has_rules:
+            body_as_dict["Rules"] = str(self.rules)
+        return json.dumps(body_as_dict, ensure_ascii=False)