Skip to content

PyTable

Bases: PyObject

The main PyTable class to interact with the tables in model.

Attributes:

Name Type Description
Name str

Name of table.
IsHidden bool

Is the table hidden.
Description str

The description of the table.
Model Tabular

The parent Tabular() class.
Partitions PyPartitions

The PyPartitions() in the table.
Columns PyColumns

The PyColumns() in the table.
Measures PyMeasures

The PyMeasures() in the table.
Example
Passing through PyTable to PyPartition
model.Tables[0].Partitions['Last Year'].refresh() # (1)
  1. This shows the ability to travel through your model to a specific partition and then running a refresh for that specific partition. model -> PyTables -> PyTable (1st index) -> PyPartitions -> PyPartition (.Name == 'Last Year') -> .refresh()
Source code in pytabular/table.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class PyTable(PyObject):
    """The main PyTable class to interact with the tables in model.

    Attributes:
        Name (str): Name of table.
        IsHidden (bool): Is the table hidden.
        Description (str): The description of the table.
        Model (Tabular): The parent `Tabular()` class.
        Partitions (PyPartitions): The `PyPartitions()` in the table.
        Columns (PyColumns): The `PyColumns()` in the table.
        Measures (PyMeasures): The `PyMeasures()` in the table.

    Example:
        ```python title="Passing through PyTable to PyPartition"

        model.Tables[0].Partitions['Last Year'].refresh() # (1)
        ```

        1. This shows the ability to travel through your model
        to a specific partition and then running a refresh
        for that specific partition.
        `model` -> `PyTables` -> `PyTable` (1st index) -> `PyPartitions`
        -> `PyPartition` (.Name == 'Last Year') -> `.refresh()`
    """

    def __init__(self, object, model) -> None:
        """Init extends from `PyObject` class.

        Also adds a few specific rows to the `rich`
        table.

        Args:
            object (Table): The actual .Net table.
            model (Tabular): The model that the table is in.
        """
        super().__init__(object)
        self.Model = model
        self.Partitions: PyPartitions = PyPartitions(
            [
                PyPartition(partition, self)
                for partition in self._object.Partitions.GetEnumerator()
            ]
        )
        self.Columns: PyColumns = PyColumns(
            [PyColumn(column, self) for column in self._object.Columns.GetEnumerator()]
        )
        self.Measures: PyMeasures = PyMeasures(
            [
                PyMeasure(measure, self)
                for measure in self._object.Measures.GetEnumerator()
            ],
            self,
        )
        self._display.add_row("# of Partitions", str(len(self.Partitions)))
        self._display.add_row("# of Columns", str(len(self.Columns)))
        self._display.add_row(
            "# of Measures", str(len(self.Measures)), end_section=True
        )
        self._display.add_row("Description", self._object.Description, end_section=True)
        self._display.add_row("DataCategory", str(self._object.DataCategory))
        self._display.add_row("IsHidden", str(self._object.IsHidden))
        self._display.add_row("IsPrivate", str(self._object.IsPrivate))
        self._display.add_row(
            "ModifiedTime",
            ticks_to_datetime(self._object.ModifiedTime.Ticks).strftime(
                "%m/%d/%Y, %H:%M:%S"
            ),
        )

    def row_count(self) -> int:
        """Method to return count of rows.

        Simple Dax Query: `EVALUATE {COUNTROWS('Table Name')}`.

        Returns:
            int: Number of rows using `COUNTROWS`.

        Example:
            ```python
            model.Tables['Table Name'].row_count()
            ```
        """
        return self.Model.Adomd.query(f"EVALUATE {{COUNTROWS('{self.Name}')}}")

    def refresh(self, *args, **kwargs) -> pd.DataFrame:
        """Use this to refresh the PyTable.

        Returns:
            pd.DataFrame: Returns pandas dataframe with some refresh details.

        Example:
            ```python
            model.Tables['Table Name'].refresh()

            model.Tables['Table Name'].refresh(trace = None) # (1)
            ```

            1. You can pass through arguments to `PyRefresh`, like removing trace.
        """
        return self.Model.refresh(self, *args, **kwargs)

    def last_refresh(self) -> datetime:
        """Will query each partition for the last refresh time.

        Then will select the max value to return.

        Returns:
            datetime: Last refresh time in datetime format
        """
        partition_refreshes = [
            partition.last_refresh() for partition in self.Partitions
        ]
        return max(partition_refreshes)

    def related(self):
        """Returns tables with a relationship with the table in question."""
        return self.Model.Relationships.related(self)

__init__(object, model)

Init extends from PyObject class.

Also adds a few specific rows to the rich table.

Parameters:

Name Type Description Default
object Table

The actual .Net table.

 required
model Tabular

The model that the table is in.

 required
Source code in pytabular/table.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
def __init__(self, object, model) -> None:
    """Init extends from `PyObject` class.

    Also adds a few specific rows to the `rich`
    table.

    Args:
        object (Table): The actual .Net table.
        model (Tabular): The model that the table is in.
    """
    super().__init__(object)
    self.Model = model
    self.Partitions: PyPartitions = PyPartitions(
        [
            PyPartition(partition, self)
            for partition in self._object.Partitions.GetEnumerator()
        ]
    )
    self.Columns: PyColumns = PyColumns(
        [PyColumn(column, self) for column in self._object.Columns.GetEnumerator()]
    )
    self.Measures: PyMeasures = PyMeasures(
        [
            PyMeasure(measure, self)
            for measure in self._object.Measures.GetEnumerator()
        ],
        self,
    )
    self._display.add_row("# of Partitions", str(len(self.Partitions)))
    self._display.add_row("# of Columns", str(len(self.Columns)))
    self._display.add_row(
        "# of Measures", str(len(self.Measures)), end_section=True
    )
    self._display.add_row("Description", self._object.Description, end_section=True)
    self._display.add_row("DataCategory", str(self._object.DataCategory))
    self._display.add_row("IsHidden", str(self._object.IsHidden))
    self._display.add_row("IsPrivate", str(self._object.IsPrivate))
    self._display.add_row(
        "ModifiedTime",
        ticks_to_datetime(self._object.ModifiedTime.Ticks).strftime(
            "%m/%d/%Y, %H:%M:%S"
        ),
    )

row_count()

Method to return count of rows.

Simple Dax Query: EVALUATE {COUNTROWS('Table Name')}.

Returns:

Name Type Description
int int

Number of rows using COUNTROWS.
Example 
model.Tables['Table Name'].row_count()
Source code in pytabular/table.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def row_count(self) -> int:
    """Method to return count of rows.

    Simple Dax Query: `EVALUATE {COUNTROWS('Table Name')}`.

    Returns:
        int: Number of rows using `COUNTROWS`.

    Example:
        ```python
        model.Tables['Table Name'].row_count()
        ```
    """
    return self.Model.Adomd.query(f"EVALUATE {{COUNTROWS('{self.Name}')}}")

refresh(*args, **kwargs)

Use this to refresh the PyTable.

Returns:

Type Description
DataFrame

pd.DataFrame: Returns pandas dataframe with some refresh details.
Example 
model.Tables['Table Name'].refresh()

model.Tables['Table Name'].refresh(trace = None) # (1)
  1. You can pass through arguments to PyRefresh, like removing trace.
Source code in pytabular/table.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def refresh(self, *args, **kwargs) -> pd.DataFrame:
    """Use this to refresh the PyTable.

    Returns:
        pd.DataFrame: Returns pandas dataframe with some refresh details.

    Example:
        ```python
        model.Tables['Table Name'].refresh()

        model.Tables['Table Name'].refresh(trace = None) # (1)
        ```

        1. You can pass through arguments to `PyRefresh`, like removing trace.
    """
    return self.Model.refresh(self, *args, **kwargs)

last_refresh()

Will query each partition for the last refresh time.

Then will select the max value to return.

Returns:

Name Type Description
datetime datetime

Last refresh time in datetime format
Source code in pytabular/table.py 
119
120
121
122
123
124
125
126
127
128
129
130
def last_refresh(self) -> datetime:
    """Will query each partition for the last refresh time.

    Then will select the max value to return.

    Returns:
        datetime: Last refresh time in datetime format
    """
    partition_refreshes = [
        partition.last_refresh() for partition in self.Partitions
    ]
    return max(partition_refreshes)

related()

Returns tables with a relationship with the table in question.

Source code in pytabular/table.py 
132
133
134
def related(self):
    """Returns tables with a relationship with the table in question."""
    return self.Model.Relationships.related(self)