def setUpClass(cls):
cls.dimension1 = Dimension(
name=DIMENSION_NAMES[0],
hierarchies=[
Hierarchy(name=DIMENSION_NAMES[0],
dimension_name=DIMENSION_NAMES[0],
elements=[
Element(name="Element_{}".format(i),
element_type="Numeric")
for i in range(1, 101)
])
])
cls.dimension2 = Dimension(
name=DIMENSION_NAMES[1],
hierarchies=[
Hierarchy(name=DIMENSION_NAMES[1],
dimension_name=DIMENSION_NAMES[1],
elements=[
Element(name="Element_{}".format(i),
element_type="Numeric")
for i in range(1, 101)
])
])
cls.cube_source = Cube(name=CUBE_NAME_SOURCE,
dimensions=DIMENSION_NAMES)
cls.cube_target = Cube(name=CUBE_NAME_TARGET,
dimensions=DIMENSION_NAMES)
def test_construct_body(self):
element = Element("e1", "Numeric")
self.assertEqual(element._construct_body(), {
'Name': 'e1',
'Type': 'Numeric'
})
def test_get_descendant_edges_recursive_true(self):
hierarchy = Hierarchy(name="NotRelevant",
dimension_name="NotRelevant",
elements=[
Element("Total", "Consolidated"),
Element("Europe", "Consolidated"),
Element("DACH", "Consolidated"),
Element("Germany", "Numeric"),
Element("Switzerland", "Numeric"),
Element("Austria", "Numeric"),
Element("France", "Numeric"),
Element("Other", "Numeric")
],
edges={
("Total", "Europe"): 1,
("Europe", "DACH"): 1,
("DACH", "Germany"): 1,
("DACH", "Switzerland"): 1,
("DACH", "Austria"): 1,
("Europe", "France"): 1,
})
edges = hierarchy.get_descendant_edges("Europe", recursive=True)
self.assertEqual(
{
("Europe", "DACH"): 1,
("DACH", "Germany"): 1,
("DACH", "Switzerland"): 1,
("DACH", "Austria"): 1,
("Europe", "France"): 1,
}, edges)
def setUpClass(cls):
"""
Establishes a connection to TM1 and creates a dimensions and a cube to use across all tests
"""
# Connection to TM1
cls.config = configparser.ConfigParser()
cls.config.read(Path(__file__).parent.joinpath('config.ini'))
cls.tm1 = TM1Service(**cls.config['tm1srv01'])
# Build Dimensions
cls.dimension_names = ("TM1py_tests_annotations_dimension1",
"TM1py_tests_annotations_dimension2",
"TM1py_tests_annotations_dimension3")
for dimension_name in cls.dimension_names:
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements)
dimension = Dimension(dimension_name, [hierarchy])
cls.tm1.dimensions.update_or_create(dimension)
# Build Cube
cls.cube_name = "TM1py_tests_annotations"
cube = Cube(cls.cube_name, cls.dimension_names)
cls.tm1.cubes.update_or_create(cube)
def setUpClass(cls):
cls.tm1 = TM1Service(**config['tm1srv01'])
# Build Dimensions
for dimension_name in cls.dimension_names:
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements)
dimension = Dimension(dimension_name, [hierarchy])
if not cls.tm1.dimensions.exists(dimension.name):
cls.tm1.dimensions.create(dimension)
# Build Cube
cube = Cube(cls.cube_name, cls.dimension_names)
if not cls.tm1.cubes.exists(cls.cube_name):
cls.tm1.cubes.create(cube)
c = Cube(cls.cube_name,
dimensions=cls.dimension_names,
rules=Rules(''))
if cls.tm1.cubes.exists(c.name):
cls.tm1.cubes.delete(c.name)
cls.tm1.cubes.create(c)
def setUp(cls):
# Connection to TM1
cls.config = configparser.ConfigParser()
cls.config.read(Path(__file__).parent.joinpath('config.ini'))
cls.tm1 = TM1Service(**cls.config['tm1srv01'])
for dimension_name in cls.dimension_names:
elements = [Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001)]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements)
dimension = Dimension(dimension_name, [hierarchy])
if not cls.tm1.dimensions.exists(dimension.name):
cls.tm1.dimensions.create(dimension)
# Build Cube
cube = Cube(cls.cube_name, cls.dimension_names)
if not cls.tm1.cubes.exists(cls.cube_name):
cls.tm1.cubes.create(cube)
c = Cube(cls.cube_name, dimensions=cls.dimension_names, rules=Rules(''))
if cls.tm1.cubes.exists(c.name):
cls.tm1.cubes.delete(c.name)
cls.tm1.cubes.create(c)
# Build Control Cube
control_cube = Cube(cls.control_cube_name, cls.dimension_names)
if not cls.tm1.cubes.exists(cls.control_cube_name):
cls.tm1.cubes.create(control_cube)
c = Cube(cls.control_cube_name, dimensions=cls.dimension_names, rules=Rules(''))
if cls.tm1.cubes.exists(c.name):
cls.tm1.cubes.delete(c.name)
cls.tm1.cubes.create(c)
def test1_create_dimension(self):
root_element = Element(name='Root', element_type='Consolidated')
elements = [root_element]
edges = []
for i in range(1000):
element_name = str(uuid.uuid4())
elements.append(Element(name=element_name, element_type='Numeric'))
edges.append(
Edge(parent_name='Root', component_name=element_name,
weight=i))
h = Hierarchy(name=self.dimension_name,
dimension_name=self.dimension_name,
elements=elements,
edges=edges)
d = Dimension(name=self.dimension_name, hierarchies=[h])
# create it
self.tm1.create_dimension(d)
# Test
dimensions = self.tm1.get_all_dimension_names()
self.assertIn(self.dimension_name, dimensions)
def test3_update_dimension(self):
# get dimension from tm1
d = self.tm1.get_dimension(dimension_name=self.dimension_name)
# create element objects
elements = [
Element(name='e1', element_type='Consolidated'),
Element(name='e2', element_type='Numeric'),
Element(name='e3', element_type='Numeric'),
Element(name='e4', element_type='Numeric')
]
# create edge objects
edges = [
Edge(parent_name='e1', component_name='e2', weight=1),
Edge(parent_name='e1', component_name='e3', weight=1),
Edge(parent_name='e1', component_name='e4', weight=1)
]
# create the element_attributes objects
element_attributes = [
ElementAttribute(name='Name Long', attribute_type='Alias'),
ElementAttribute(name='Name Short', attribute_type='Alias'),
ElementAttribute(name='Currency', attribute_type='String')
]
# create hierarchy object
hierarchy = Hierarchy(name=self.dimension_name,
dimension_name=self.dimension_name,
elements=elements,
element_attributes=element_attributes,
edges=edges)
# replace existing hierarchy with new hierarchy
d.remove_hierarchy(self.dimension_name)
d.add_hierarchy(hierarchy)
# update dimension in TM1
self.tm1.update_dimension(d)
# Test
dimension = self.tm1.get_dimension(self.dimension_name)
self.assertEqual(len(dimension.hierarchies[0].elements), len(elements))
def setup_class(cls):
# Connection to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# Build Dimensions
for dimension_name in cls.dimension_names:
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements)
dimension = Dimension(dimension_name, [hierarchy])
if not cls.tm1.dimensions.exists(dimension.name):
cls.tm1.dimensions.create(dimension)
# Build Cube
cube = Cube(cls.cube_name, cls.dimension_names)
if not cls.tm1.cubes.exists(cls.cube_name):
cls.tm1.cubes.create(cube)
cls.create_annotation()
def setUpClass(cls) -> None:
# Build Dimensions
for dimension_name in DIMENSION_NAMES:
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
element_attributes = [
ElementAttribute("Attr1", "String"),
ElementAttribute("Attr2", "Numeric"),
ElementAttribute("Attr3", "Numeric")
]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements,
element_attributes=element_attributes)
dimension = Dimension(dimension_name, [hierarchy])
if cls.tm1.dimensions.exists(dimension.name):
cls.tm1.dimensions.update(dimension)
else:
cls.tm1.dimensions.create(dimension)
# Build Cube
cube = Cube(CUBE_NAME, DIMENSION_NAMES)
if not cls.tm1.cubes.exists(CUBE_NAME):
cls.tm1.cubes.create(cube)
# Build cube view
view = NativeView(cube_name=CUBE_NAME,
view_name=VIEW_NAME,
suppress_empty_columns=True,
suppress_empty_rows=True)
view.add_row(dimension_name=DIMENSION_NAMES[0],
subset=AnonymousSubset(dimension_name=DIMENSION_NAMES[0],
expression='{[' +
DIMENSION_NAMES[0] + '].Members}'))
view.add_row(dimension_name=DIMENSION_NAMES[1],
subset=AnonymousSubset(dimension_name=DIMENSION_NAMES[1],
expression='{[' +
DIMENSION_NAMES[1] + '].Members}'))
view.add_column(
dimension_name=DIMENSION_NAMES[2],
subset=AnonymousSubset(dimension_name=DIMENSION_NAMES[2],
expression='{[' + DIMENSION_NAMES[2] +
'].Members}'))
if not cls.tm1.cubes.views.exists(CUBE_NAME, view.name, private=False):
cls.tm1.cubes.views.create(view=view, private=False)
# Build subset
subset = Subset(SUBSET_NAME, DIMENSION_NAMES[0], DIMENSION_NAMES[0],
None, None, ["Element 1"])
if cls.tm1.dimensions.hierarchies.subsets.exists(
subset.name, subset.dimension_name, subset.hierarchy_name,
False):
cls.tm1.dimensions.hierarchies.subsets.delete(
subset.name, subset.dimension_name, subset.hierarchy_name,
False)
cls.tm1.dimensions.hierarchies.subsets.create(subset, False)
# Build process
p1 = Process(name=PROCESS_NAME)
p1.add_parameter('pRegion', 'pRegion (String)', value='US')
if cls.tm1.processes.exists(p1.name):
cls.tm1.processes.delete(p1.name)
cls.tm1.processes.create(p1)
# Build chore
c1 = Chore(name=CHORE_NAME,
start_time=ChoreStartTime(datetime.now().year,
datetime.now().month,
datetime.now().day,
datetime.now().hour,
datetime.now().minute,
datetime.now().second),
dst_sensitivity=False,
active=True,
execution_mode=Chore.MULTIPLE_COMMIT,
frequency=ChoreFrequency(days=int(random.uniform(0, 355)),
hours=int(random.uniform(0, 23)),
minutes=int(random.uniform(0, 59)),
seconds=int(random.uniform(0,
59))),
tasks=[
ChoreTask(0,
PROCESS_NAME,
parameters=[{
'Name': 'pRegion',
'Value': 'UK'
}])
])
cls.tm1.chores.create(c1)
# create Folder
app = FolderApplication("", TM1PY_APP_FOLDER)
cls.tm1.applications.create(application=app, private=False)
def setUpClass(cls) -> None:
"""
Establishes a connection to TM1 and creates TM1 objects to use across all tests
"""
# Connection to TM1
cls.config = configparser.ConfigParser()
cls.config.read(Path(__file__).parent.joinpath('config.ini'))
cls.tm1 = TM1Service(**cls.config['tm1srv01'])
# Build Dimensions
for dimension_name in cls.dimension_names:
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
element_attributes = [
ElementAttribute("Attr1", "String"),
ElementAttribute("Attr2", "Numeric"),
ElementAttribute("Attr3", "Numeric")
]
hierarchy = Hierarchy(dimension_name=dimension_name,
name=dimension_name,
elements=elements,
element_attributes=element_attributes)
dimension = Dimension(dimension_name, [hierarchy])
if cls.tm1.dimensions.exists(dimension.name):
cls.tm1.dimensions.update(dimension)
else:
cls.tm1.dimensions.create(dimension)
# Build Cube
cube = Cube(cls.cube_name, cls.dimension_names)
if not cls.tm1.cubes.exists(cls.cube_name):
cls.tm1.cubes.create(cube)
# Build cube view
view = NativeView(cube_name=cls.cube_name,
view_name=cls.view_name,
suppress_empty_columns=True,
suppress_empty_rows=True)
view.add_row(
dimension_name=cls.dimension_names[0],
subset=AnonymousSubset(dimension_name=cls.dimension_names[0],
expression='{[' + cls.dimension_names[0] +
'].Members}'))
view.add_row(
dimension_name=cls.dimension_names[1],
subset=AnonymousSubset(dimension_name=cls.dimension_names[1],
expression='{[' + cls.dimension_names[1] +
'].Members}'))
view.add_column(
dimension_name=cls.dimension_names[2],
subset=AnonymousSubset(dimension_name=cls.dimension_names[2],
expression='{[' + cls.dimension_names[2] +
'].Members}'))
if not cls.tm1.cubes.views.exists(
cls.cube_name, view.name, private=False):
cls.tm1.cubes.views.create(view=view, private=False)
# Build subset
subset = Subset(cls.subset_name, cls.dimension_names[0],
cls.dimension_names[0], None, None, ["Element 1"])
if cls.tm1.dimensions.hierarchies.subsets.exists(
subset.name, subset.dimension_name, subset.hierarchy_name,
False):
cls.tm1.dimensions.hierarchies.subsets.delete(
subset.name, subset.dimension_name, subset.hierarchy_name,
False)
cls.tm1.dimensions.hierarchies.subsets.create(subset, False)
# Build process
p1 = Process(name=cls.process_name)
p1.add_parameter('pRegion', 'pRegion (String)', value='US')
if cls.tm1.processes.exists(p1.name):
cls.tm1.processes.delete(p1.name)
cls.tm1.processes.create(p1)
# Build chore
c1 = Chore(name=cls.chore_name,
start_time=ChoreStartTime(datetime.now().year,
datetime.now().month,
datetime.now().day,
datetime.now().hour,
datetime.now().minute,
datetime.now().second),
dst_sensitivity=False,
active=True,
execution_mode=Chore.MULTIPLE_COMMIT,
frequency=ChoreFrequency(days=int(random.uniform(0, 355)),
hours=int(random.uniform(0, 23)),
minutes=int(random.uniform(0, 59)),
seconds=int(random.uniform(0,
59))),
tasks=[
ChoreTask(0,
cls.process_name,
parameters=[{
'Name': 'pRegion',
'Value': 'UK'
}])
])
cls.tm1.chores.create(c1)
# create Folder
app = FolderApplication("", cls.tm1py_app_folder)
cls.tm1.applications.create(application=app, private=False)
CONFIG = "config.ini"
config = configparser.ConfigParser()
config.read(CONFIG)
with TM1Service(**config['tm1srv01']) as tm1:
# create dimensions
dimension = Dimension(
name="Py Project")
hierarchy = Hierarchy(
name="Py Project",
dimension_name="Py Project",
elements=[
Element("Project1", "Numeric"),
Element("Project2", "Numeric"),
Element("Project3", "Numeric")])
dimension.add_hierarchy(hierarchy)
if not tm1.dimensions.exists(dimension.name):
tm1.dimensions.create(dimension)
dimension = Dimension(
name="Py Quarter")
hierarchy = Hierarchy(
name="Py Quarter",
dimension_name="Py Quarter",
elements=[
Element("2018-Q1", "Numeric"),
Element("2018-Q2", "Numeric"),
Element("2018-Q3", "Numeric"),
def test_eq_happy_case(self):
element1 = Element(name="Element 1", element_type="Numeric")
element2 = Element(name="Element 1", element_type="NUMERIC")
self.assertEqual(element1, element2)
def test_hash_happy_case(self):
element1 = Element(name="Element 1", element_type="Numeric")
element2 = Element(name="Element 1", element_type="Numeric")
self.assertEqual(hash(element1), hash(element2))
def test_eq_case_space_difference(self):
element1 = Element(name="Element 1", element_type="Numeric")
element2 = Element(name="ELEMENT1", element_type="NUMERIC")
self.assertEqual(element1, element2)
from TM1py import TM1pyQueries as TM1, TM1pyLogin, Dimension, Hierarchy, Element, Edge, ElementAttribute
# login object
login = TM1pyLogin.native('admin', 'apple')
name = 'TM1py Region'
# Connection to TM1. Needs IP, Port, Credentials, and SSL
with TM1(ip='', port=8001, login=login, ssl=False) as tm1:
# create elements objects
elements = [
Element(name='Europe', element_type='Consolidated'),
Element(name='CH', element_type='Numeric'),
Element(name='UK', element_type='Numeric'),
Element(name='BE', element_type='Numeric')
]
# create edge object
edges = [
Edge(parent_name='Europe', component_name='CH', weight=1),
Edge(parent_name='Europe', component_name='UK', weight=1),
Edge(parent_name='Europe', component_name='BE', weight=1)
]
# create the element_attributes
element_attributes = [
ElementAttribute(name='Name Long', attribute_type='Alias'),
ElementAttribute(name='Name Short', attribute_type='Alias'),
ElementAttribute(name='Currency', attribute_type='String')
]
