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)
if not cls.tm1.sandboxes.exists(cls.sandbox_name1):
cls.tm1.sandboxes.create(
Sandbox(name=cls.sandbox_name1,
include_in_sandbox_dimension=True))
def test_get_all_names(self):
all_cubes_before = self.tm1.cubes.get_all_names()
cubes_with_rules = self.tm1.cubes.get_all_names_with_rules()
cubes_without_rules = self.tm1.cubes.get_all_names_without_rules()
self.assertEqual(len(all_cubes_before),
len(cubes_with_rules) + len(cubes_without_rules))
cube_name = self.prefix + "Some_Other_Name"
dimension_names = self.tm1.dimensions.get_all_names()[1:3]
cube = Cube(cube_name, dimension_names)
self.tm1.cubes.create(cube)
self.assertEqual(
len(cubes_without_rules) + 1,
len(self.tm1.cubes.get_all_names_without_rules()))
self.assertEqual(len(cubes_with_rules),
len(self.tm1.cubes.get_all_names_with_rules()))
cube.rules = "SKIPCHECK"
self.tm1.cubes.update(cube)
self.assertEqual(
len(cubes_with_rules) + 1,
len(self.tm1.cubes.get_all_names_with_rules()))
self.assertEqual(len(cubes_without_rules),
len(self.tm1.cubes.get_all_names_without_rules()))
self.tm1.cubes.delete(cube_name)
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'])
cls.prefix = "TM1py_Tests_Cube_"
cls.cube_name = cls.prefix + "some_name"
cls.dimension_names = [
cls.prefix + "dimension1",
cls.prefix + "dimension2",
cls.prefix + "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])
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 setUpClass(cls):
# Namings
cls.prefix = "TM1py_unittest_server_"
cls.dimension_name1 = cls.prefix + str(uuid.uuid4())
cls.dimension_name2 = cls.prefix + str(uuid.uuid4())
cls.cube_name = cls.prefix + str(uuid.uuid4())
cls.process_name1 = cls.prefix + str(uuid.uuid4())
cls.process_name2 = cls.prefix + str(uuid.uuid4())
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# create a simple cube with dimensions to test transactionlog methods
if not cls.tm1.dimensions.exists(cls.dimension_name1):
d = Dimension(cls.dimension_name1)
h = Hierarchy(cls.dimension_name1, cls.dimension_name1)
h.add_element('Total Years', 'Consolidated')
h.add_element('No Year', 'Numeric')
for year in range(1989, 2040, 1):
h.add_element(str(year), 'Numeric')
h.add_edge('Total Years', str(year), 1)
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
if not cls.tm1.dimensions.exists(cls.dimension_name2):
d = Dimension(cls.dimension_name2)
h = Hierarchy(cls.dimension_name2, cls.dimension_name2)
h.add_element('Value', 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
if not cls.tm1.cubes.exists(cls.cube_name):
cube = Cube(cls.cube_name,
[cls.dimension_name1, cls.dimension_name2])
cls.tm1.cubes.create(cube)
def setup_class(cls):
# Build Dimensions
for i in range(3):
elements = [Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001)]
hierarchy = Hierarchy(
dimension_name=DIMENSION_NAMES[i],
name=DIMENSION_NAMES[i],
elements=elements)
dimension = Dimension(
name=DIMENSION_NAMES[i],
hierarchies=[hierarchy])
if not cls.tm1.dimensions.exists(dimension_name=dimension.name):
cls.tm1.dimensions.create(dimension=dimension)
# Build Cube
cube = Cube(CUBE_NAME, DIMENSION_NAMES)
if not cls.tm1.cubes.exists(CUBE_NAME):
cls.tm1.cubes.create(cube)
# Write data into cube
cellset = {}
for i in range(20000):
element1 = 'Element ' + str(random.randint(1, 1000))
element2 = 'Element ' + str(random.randint(1, 1000))
element3 = 'Element ' + str(random.randint(1, 1000))
cellset[(element1, element2, element3)] = random.randint(1, 1000)
cls.tm1.data.write_values(CUBE_NAME, cellset)
def build_cube(tm1, name, dimensions, rules=None, overwrite=False):
cube = Cube(name, dimensions, rules=rules)
exists = tm1.cubes.exists(name)
if not exists:
tm1.cubes.create(cube)
if exists and overwrite:
tm1.cubes.update(cube)
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):
"""
Establishes a connection to TM1 and creates TM! 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 i in range(3):
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
hierarchy = Hierarchy(dimension_name=cls.dimension_names[i],
name=cls.dimension_names[i],
elements=elements)
dimension = Dimension(name=cls.dimension_names[i],
hierarchies=[hierarchy])
if not cls.tm1.dimensions.exists(dimension_name=dimension.name):
cls.tm1.dimensions.create(dimension=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)
# Write data into cube
cellset = {}
for i in range(20000):
element1 = 'Element ' + str(random.randint(1, 1000))
element2 = 'Element ' + str(random.randint(1, 1000))
element3 = 'Element ' + str(random.randint(1, 1000))
cellset[(element1, element2, element3)] = random.randint(1, 1000)
cls.tm1.cells.write_values(cls.cube_name, cellset)
def setup_class(cls):
# Connection to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# generate random coordinates
cls.target_coordinates = list(
zip(('Element ' + str(random.randint(1, 1000))
for _ in range(100)),
('Element ' + str(random.randint(1, 1000))
for _ in range(100)),
('Element ' + str(random.randint(1, 1000))
for _ in range(100))))
# Build Dimensions
for i in range(3):
elements = [
Element('Element {}'.format(str(j)), 'Numeric')
for j in range(1, 1001)
]
hierarchy = Hierarchy(dimension_names[i], dimension_names[i],
elements)
dimension = Dimension(dimension_names[i], [hierarchy])
if not cls.tm1.dimensions.exists(dimension.name):
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)
subset = AnonymousSubset(dimension_name=dimension_names[0],
expression='{[' + dimension_names[0] +
'].Members}')
view.add_row(dimension_name=dimension_names[0], subset=subset)
subset = AnonymousSubset(dimension_name=dimension_names[1],
expression='{[' + dimension_names[1] +
'].Members}')
view.add_row(dimension_name=dimension_names[1], subset=subset)
subset = AnonymousSubset(dimension_name=dimension_names[2],
expression='{[' + dimension_names[2] +
'].Members}')
view.add_column(dimension_name=dimension_names[2], subset=subset)
cls.tm1.cubes.views.create(view, private=False)
# Sum of all the values that we write in the cube. serves as a checksum
cls.total_value = 0
# cellset of data that shall be written
cls.cellset = {}
for element1, element2, element3 in cls.target_coordinates:
value = random.randint(1, 1000)
cls.cellset[(element1, element2, element3)] = value
# update the checksum
cls.total_value += value
def setUpClass(cls):
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# Build 4 Dimensions
cls.dim1_name = str(uuid.uuid4())
cls.dim1_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim1_name)
h = Hierarchy(cls.dim1_name, cls.dim1_name)
for element_name in cls.dim1_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim2_name = str(uuid.uuid4())
cls.dim2_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim2_name)
h = Hierarchy(cls.dim2_name, cls.dim2_name)
for element_name in cls.dim2_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim3_name = str(uuid.uuid4())
cls.dim3_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim3_name)
h = Hierarchy(cls.dim3_name, cls.dim3_name)
for element_name in cls.dim3_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim4_name = str(uuid.uuid4())
cls.dim4_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim4_name)
h = Hierarchy(cls.dim4_name, cls.dim4_name)
for element_name in cls.dim4_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
# Build Subset
cls.dim4_subset_Name = "TM1pyTests"
cls.dim4_subset = cls.tm1.dimensions.subsets.create(
Subset(subset_name=cls.dim4_subset_Name,
dimension_name=cls.dim4_name,
hierarchy_name=cls.dim4_name,
expression="HEAD([{}].Members, 1)".format(cls.dim4_name)))
# Build Cube with 4 Dimensions
cls.cube_name = str(uuid.uuid4())
cube = Cube(name=cls.cube_name,
dimensions=[
cls.dim1_name, cls.dim2_name, cls.dim3_name,
cls.dim4_name
])
cls.tm1.cubes.create(cube)
def setUpClass(cls):
"""
Establishes a connection to TM1 and creates TM! 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'])
# Namings
cls.dimension_name1 = PREFIX + "Dimension1"
cls.dimension_name2 = PREFIX + "Dimension2"
cls.cube_name = PREFIX + "Cube1"
cls.process_name1 = PREFIX + "Process1"
cls.process_name2 = PREFIX + "Process2"
# create a simple cube with dimensions to test transactionlog methods
if not cls.tm1.dimensions.exists(cls.dimension_name1):
d = Dimension(cls.dimension_name1)
h = Hierarchy(cls.dimension_name1, cls.dimension_name1)
h.add_element('Total Years', 'Consolidated')
h.add_element('No Year', 'Numeric')
for year in range(1989, 2040, 1):
h.add_element(str(year), 'Numeric')
h.add_edge('Total Years', str(year), 1)
d.add_hierarchy(h)
cls.tm1.dimensions.update_or_create(d)
if not cls.tm1.dimensions.exists(cls.dimension_name2):
d = Dimension(cls.dimension_name2)
h = Hierarchy(cls.dimension_name2, cls.dimension_name2)
h.add_element('Value', 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.update_or_create(d)
if not cls.tm1.cubes.exists(cls.cube_name):
cube = Cube(cls.cube_name,
[cls.dimension_name1, cls.dimension_name2])
cls.tm1.cubes.update_or_create(cube)
# inject process with ItemReject
cls.process1 = Process(name=cls.process_name1,
prolog_procedure="ItemReject('TM1py Tests');")
cls.tm1.processes.update_or_create(cls.process1)
# inject process that does nothing and runs successful
cls.process2 = Process(name=cls.process_name2,
prolog_procedure="sText = 'text';")
cls.tm1.processes.update_or_create(cls.process2)
cls.tm1.server.activate_audit_log()
def setUpClass(cls):
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# Build 4 Dimensions
cls.dim1_name = str(uuid.uuid4())
cls.dim1_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim1_name)
h = Hierarchy(cls.dim1_name, cls.dim1_name)
for element_name in cls.dim1_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim2_name = str(uuid.uuid4())
cls.dim2_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim2_name)
h = Hierarchy(cls.dim2_name, cls.dim2_name)
for element_name in cls.dim2_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim3_name = str(uuid.uuid4())
cls.dim3_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim3_name)
h = Hierarchy(cls.dim3_name, cls.dim3_name)
for element_name in cls.dim3_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
cls.dim4_name = str(uuid.uuid4())
cls.dim4_element_names = [str(uuid.uuid4()) for _ in range(10)]
d = Dimension(cls.dim4_name)
h = Hierarchy(cls.dim4_name, cls.dim4_name)
for element_name in cls.dim4_element_names:
h.add_element(element_name, 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
# Build Cube with 4 Dimensions
cls.cube_name = str(uuid.uuid4())
cube = Cube(name=cls.cube_name,
dimensions=[
cls.dim1_name, cls.dim2_name, cls.dim3_name,
cls.dim4_name
])
cls.tm1.cubes.create(cube)
def setUpClass(cls):
"""
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 4 Dimensions
cls.dim1_name = PREFIX + "Dimension1"
cls.dim1_element_names = ["A " + str(i) for i in range(10)]
cls.dim1 = Dimension(cls.dim1_name)
h = Hierarchy(cls.dim1_name, cls.dim1_name)
for element_name in cls.dim1_element_names:
h.add_element(element_name, "Numeric")
cls.dim1.add_hierarchy(h)
cls.dim2_name = PREFIX + "Dimension2"
cls.dim2_element_names = ["B " + str(i) for i in range(10)]
cls.dim2 = Dimension(cls.dim2_name)
h = Hierarchy(cls.dim2_name, cls.dim2_name)
for element_name in cls.dim2_element_names:
h.add_element(element_name, "Numeric")
cls.dim2.add_hierarchy(h)
cls.dim3_name = PREFIX + "Dimension3"
cls.dim3_element_names = ["C " + str(i) for i in range(10)]
cls.dim3 = Dimension(cls.dim3_name)
h = Hierarchy(cls.dim3_name, cls.dim3_name)
for element_name in cls.dim3_element_names:
h.add_element(element_name, "Numeric")
cls.dim3.add_hierarchy(h)
cls.dim4_name = PREFIX + "Dimension4"
cls.dim4_element_names = ["D " + str(i) for i in range(10)]
cls.dim4 = Dimension(cls.dim4_name)
h = Hierarchy(cls.dim4_name, cls.dim4_name)
for element_name in cls.dim4_element_names:
h.add_element(element_name, "Numeric")
cls.dim4.add_hierarchy(h)
# Define cube with 4 dimensions
cls.cube_name = PREFIX + "Cube"
cls.cube = Cube(
name=cls.cube_name,
dimensions=[cls.dim1_name, cls.dim2_name, cls.dim3_name, cls.dim4_name],
)
def test1_create_cube(self):
all_cubes_before = self.tm1.cubes.get_all_names()
dimensions = self.tm1.dimensions.get_all_names()
shuffle(dimensions)
dimensions = dimensions[0:10]
c = Cube(self.cube_name, dimensions=dimensions, rules=Rules(''))
self.tm1.cubes.create(c)
all_cubes_after = self.tm1.cubes.get_all_names()
self.assertEqual(len(all_cubes_before) + 1, len(all_cubes_after))
self.assertEqual(self.tm1.cubes.get_dimension_names(self.cube_name),
dimensions)
def test_create_delete_cube(self):
cube_name = PREFIX + "Some_Other_Name"
dimension_names = self.tm1.dimensions.get_all_names()[0:2]
cube = Cube(cube_name, dimension_names)
all_cubes_before = self.tm1.cubes.get_all_names()
self.tm1.cubes.create(cube)
all_cubes_after = self.tm1.cubes.get_all_names()
self.assertEqual(len(all_cubes_before) + 1, len(all_cubes_after))
self.assertEqual(self.tm1.cubes.get_dimension_names(cube_name),
dimension_names)
all_cubes_before = self.tm1.cubes.get_all_names()
self.tm1.cubes.delete(cube_name)
all_cubes_after = self.tm1.cubes.get_all_names()
self.assertEqual(len(all_cubes_before) - 1, len(all_cubes_after))
def test_create_delete_cube(self):
cube_name = self.prefix + "Some_Other_Name"
# element with index 0 is Sandboxes
dimension_names = self.tm1.dimensions.get_all_names()[1:3]
cube = Cube(cube_name, dimension_names)
all_cubes_before = self.tm1.cubes.get_all_names()
self.tm1.cubes.create(cube)
all_cubes_after = self.tm1.cubes.get_all_names()
self.assertEqual(len(all_cubes_before) + 1, len(all_cubes_after))
self.assertEqual(self.tm1.cubes.get_dimension_names(cube_name),
dimension_names)
all_cubes_before = self.tm1.cubes.get_all_names()
self.tm1.cubes.delete(cube_name)
all_cubes_after = self.tm1.cubes.get_all_names()
self.assertEqual(len(all_cubes_before) - 1, len(all_cubes_after))
def setUpClass(cls):
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# Build 4 Dimensions
cls.dim1_name = PREFIX + "Dimension1"
cls.dim1_element_names = ["A " + str(i) for i in range(10)]
cls.dim1 = Dimension(cls.dim1_name)
h = Hierarchy(cls.dim1_name, cls.dim1_name)
for element_name in cls.dim1_element_names:
h.add_element(element_name, 'Numeric')
cls.dim1.add_hierarchy(h)
cls.dim2_name = PREFIX + "Dimension2"
cls.dim2_element_names = ["B " + str(i) for i in range(10)]
cls.dim2 = Dimension(cls.dim2_name)
h = Hierarchy(cls.dim2_name, cls.dim2_name)
for element_name in cls.dim2_element_names:
h.add_element(element_name, 'Numeric')
cls.dim2.add_hierarchy(h)
cls.dim3_name = PREFIX + "Dimension3"
cls.dim3_element_names = ["C " + str(i) for i in range(10)]
cls.dim3 = Dimension(cls.dim3_name)
h = Hierarchy(cls.dim3_name, cls.dim3_name)
for element_name in cls.dim3_element_names:
h.add_element(element_name, 'Numeric')
cls.dim3.add_hierarchy(h)
cls.dim4_name = PREFIX + "Dimension4"
cls.dim4_element_names = ["D " + str(i) for i in range(10)]
cls.dim4 = Dimension(cls.dim4_name)
h = Hierarchy(cls.dim4_name, cls.dim4_name)
for element_name in cls.dim4_element_names:
h.add_element(element_name, 'Numeric')
cls.dim4.add_hierarchy(h)
# Define cube with 4 dimensions
cls.cube_name = PREFIX + "Cube"
cls.cube = Cube(name=cls.cube_name,
dimensions=[
cls.dim1_name, cls.dim2_name, cls.dim3_name,
cls.dim4_name
])
def setUpClass(cls):
# Namings
cls.dimension_name1 = PREFIX + "Dimension1"
cls.dimension_name2 = PREFIX + "Dimension2"
cls.cube_name = PREFIX + "Cube1"
cls.process_name1 = PREFIX + "Process1"
cls.process_name2 = PREFIX + "Process2"
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# create a simple cube with dimensions to test transactionlog methods
if not cls.tm1.dimensions.exists(cls.dimension_name1):
d = Dimension(cls.dimension_name1)
h = Hierarchy(cls.dimension_name1, cls.dimension_name1)
h.add_element('Total Years', 'Consolidated')
h.add_element('No Year', 'Numeric')
for year in range(1989, 2040, 1):
h.add_element(str(year), 'Numeric')
h.add_edge('Total Years', str(year), 1)
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
if not cls.tm1.dimensions.exists(cls.dimension_name2):
d = Dimension(cls.dimension_name2)
h = Hierarchy(cls.dimension_name2, cls.dimension_name2)
h.add_element('Value', 'Numeric')
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
if not cls.tm1.cubes.exists(cls.cube_name):
cube = Cube(cls.cube_name,
[cls.dimension_name1, cls.dimension_name2])
cls.tm1.cubes.create(cube)
# inject process with ItemReject
cls.process1 = Process(name=cls.process_name1,
prolog_procedure="ItemReject('TM1py Tests');")
cls.tm1.processes.create(cls.process1)
# inject process that does nothing and runs successfull
cls.process2 = Process(name=cls.process_name2,
prolog_procedure="sText = 'text';")
cls.tm1.processes.create(cls.process2)
def create_dimensions_and_cube():
with TM1Service(**config['tm1srv01']) as tm1:
# Build Measure Dimension
element = Element('Numeric Element', 'Numeric')
hierarchy1 = Hierarchy('Python Cube Measure', 'Python Cube Measure', [element])
dimension1 = Dimension('Python Cube Measure', [hierarchy1])
if not tm1.dimensions.exists(dimension1.name):
tm1.dimensions.create(dimension1)
# Build Index Dimension
elements = [Element(str(num), 'Numeric') for num in range(1, 100000)]
hierarchy2 = Hierarchy('Big Dimension', 'Big Dimension', elements)
dimension2 = Dimension('Big Dimension', [hierarchy2])
if not tm1.dimensions.exists(dimension2.name):
tm1.dimensions.create(dimension2)
cube = Cube('Python Cube', [dimension2.name, dimension1.name])
if cube.name not in tm1.cubes.get_all_names():
tm1.cubes.create(cube)
def create_dimensions_and_cube():
with TM1Service(address='localhost',
port=12354,
user='******',
password='******',
ssl=True) as tm1:
# Build Measure Dimension
element = Element('Numeric Element', 'Numeric')
hierarchy1 = Hierarchy('Python Cube Measure', 'Python Cube Measure',
[element])
dimension1 = Dimension('Python Cube Measure', [hierarchy1])
if not tm1.dimensions.exists(dimension1.name):
tm1.dimensions.create(dimension1)
# Build Index Dimension
elements = [Element(str(num), 'Numeric') for num in range(1, 100000)]
hierarchy2 = Hierarchy('Big Dimension', 'Big Dimension', elements)
dimension2 = Dimension('Big Dimension', [hierarchy2])
if not tm1.dimensions.exists(dimension2.name):
tm1.dimensions.create(dimension2)
cube = Cube('Python Cube', [dimension2.name, dimension1.name])
if cube.name not in tm1.cubes.get_all_names():
tm1.cubes.create(cube)
def setUpClass(cls):
"""
Establishes a connection to TM1 and creates TM! 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'])
# generate random coordinates
cls.target_coordinates = list(
zip(('Element ' + str(e) for e in range(1, 100)),
('Element ' + str(e) for e in range(1, 100)),
('Element ' + str(e) for e in range(1, 100))))
# 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)
attribute_cube = "}ElementAttributes_" + dimension_name
attribute_values = dict()
for element in elements:
attribute_values[(element.name, "Attr1")] = "TM1py"
attribute_values[(element.name, "Attr2")] = "2"
attribute_values[(element.name, "Attr3")] = "3"
cls.tm1.cubes.cells.write_values(attribute_cube, attribute_values)
# Build Cube
cube = Cube(CUBE_NAME, DIMENSION_NAMES)
if not cls.tm1.cubes.exists(CUBE_NAME):
cls.tm1.cubes.create(cube)
# Sum of all the values that we write in the cube. serves as a checksum.
cls.total_value = 0
# cellset of data that shall be written
cls.cellset = {}
for element1, element2, element3 in cls.target_coordinates:
value = 1
cls.cellset[(element1, element2, element3)] = value
# update the checksum
cls.total_value += value
# Fill cube with values
cls.tm1.cubes.cells.write_values(CUBE_NAME, cls.cellset)
# Elements
cls.years = ("No Year", "1989", "1990", "1991", "1992")
cls.extra_year = "4321"
# Element Attributes
cls.attributes = ('Previous Year', 'Next Year')
cls.alias_attributes = ("Financial Year", )
# create dimension with a default hierarchy
d = Dimension(DIMENSION_NAME)
h = Hierarchy(DIMENSION_NAME, DIMENSION_NAME)
h.add_element('Total Years', 'Consolidated')
h.add_element('All Consolidations', 'Consolidated')
h.add_edge("All Consolidations", "Total Years", 1)
for year in cls.years:
h.add_element(year, 'Numeric')
h.add_edge('Total Years', year, 1)
for attribute in cls.attributes:
h.add_element_attribute(attribute, "String")
for attribute in cls.alias_attributes:
h.add_element_attribute(attribute, "Alias")
d.add_hierarchy(h)
cls.tm1.dimensions.update_or_create(d)
# write attribute values
cls.tm1.cubes.cells.write_value('1988',
'}ElementAttributes_' + DIMENSION_NAME,
('1989', 'Previous Year'))
cls.tm1.cubes.cells.write_value('1989',
'}ElementAttributes_' + DIMENSION_NAME,
('1990', 'Previous Year'))
cls.tm1.cubes.cells.write_value('1990',
'}ElementAttributes_' + DIMENSION_NAME,
('1991', 'Previous Year'))
cls.tm1.cubes.cells.write_value('1991',
'}ElementAttributes_' + DIMENSION_NAME,
('1992', 'Previous Year'))
cls.tm1.cubes.cells.write_value('1988/89',
'}ElementAttributes_' + DIMENSION_NAME,
('1989', 'Financial Year'))
cls.tm1.cubes.cells.write_value('1989/90',
'}ElementAttributes_' + DIMENSION_NAME,
('1990', 'Financial Year'))
cls.tm1.cubes.cells.write_value('1990/91',
'}ElementAttributes_' + DIMENSION_NAME,
('1991', 'Financial Year'))
cls.tm1.cubes.cells.write_value('1991/92',
'}ElementAttributes_' + DIMENSION_NAME,
('1992', 'Financial Year'))
def setUpClass(cls):
# Namings
cls.expand_process_name = str(uuid.uuid4())
cls.expand_process_name_obf = str(uuid.uuid4())
cls.process_name = str(uuid.uuid4())
cls.process_name_obf = str(uuid.uuid4())
cls.dimension_name = str(uuid.uuid4())
cls.dimension_name_cloned = str(uuid.uuid4())
cls.cube_name = str(uuid.uuid4())
cls.cube_name_cloned = str(uuid.uuid4())
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# create process
prolog = "\r\nSaveDataAll;\r\nsText='abcABC';\r\n"
epilog = "SaveDataAll;"
cls.process = Process(
name=cls.process_name,
prolog_procedure=prolog,
epilog_procedure=epilog)
# create process with expand in TM1
if cls.tm1.processes.exists(cls.process.name):
cls.tm1.processes.delete(cls.process.name)
cls.tm1.processes.create(cls.process)
# create process with expand
prolog = "\r\nnRevenue = 20;\r\nsRevenue = EXPAND('%nrevenue%');\r\nIF(sRevenue @ <> '20.000');\r\n" \
"ProcessBreak;\r\nENDIF;"
cls.expand_process = Process(
name=cls.expand_process_name,
prolog_procedure=prolog)
# create process with expand in TM1
if cls.tm1.processes.exists(cls.expand_process.name):
cls.tm1.processes.delete(cls.expand_process.name)
cls.tm1.processes.create(cls.expand_process)
# create dimension that we clone through obfuscated bedrock as part of the test
if not cls.tm1.dimensions.exists(cls.dimension_name):
d = Dimension(cls.dimension_name)
h = Hierarchy(cls.dimension_name, cls.dimension_name)
h.add_element('Total Years', 'Consolidated')
h.add_element('No Year', 'Numeric')
for year in range(1989, 2040, 1):
h.add_element(str(year), 'Numeric')
h.add_edge('Total Years', str(year), 1)
d.add_hierarchy(h)
cls.tm1.dimensions.create(d)
# Create 2 Attributes through TI
ti_statements = ["AttrInsert('{}','','Previous Year', 'S')".format(cls.dimension_name),
"AttrInsert('{}','','Next Year', 'S');".format(cls.dimension_name)]
ti = ';'.join(ti_statements)
cls.tm1.processes.execute_ti_code(lines_prolog=ti)
# create }ElementAttribute values
cellset = {}
for year in range(1989, 2040, 1):
cellset[(str(year), 'Previous Year')] = year - 1
cellset[(str(year), 'Next Year')] = year + 1
cls.tm1.cubes.cells.write_values("}ElementAttributes_" + cls.dimension_name, cellset)
# create a simple cube to be cloned through bedrock
if not cls.tm1.cubes.exists(cls.cube_name):
cube = Cube(cls.cube_name, ["}Dimensions", "}Cubes"], "[]=S:'TM1py';")
cls.tm1.cubes.create(cube)
# create bedrocks if they doesn't exist
for bedrock in ("Bedrock.Dim.Clone", "Bedrock.Cube.Clone"):
if not cls.tm1.processes.exists(bedrock):
with open(os.path.join("resources", bedrock + ".json"), "r") as file:
process = Process.from_json(file.read())
cls.tm1.processes.create(process)
"""
Create a cube with 4 dimensions: red, green, blue, yellow
Assumption: Dimensions (red, green, blue, yellow) exist in tm1 model
"""
import configparser
from TM1py.Objects import Cube
from TM1py.Services import TM1Service
config = configparser.ConfigParser()
config.read(r'..\config.ini')
# connection to TM1 Server
with TM1Service(**config['tm1srv01']) as tm1:
cube = Cube(name='Rubiks Cube',
dimensions=['red', 'green', 'blue', 'yellow'],
rules='')
tm1.cubes.create(cube)
if not tm1.dimensions.exists(dimension.name):
tm1.dimensions.create(dimension)
# create dimension TM1py Year
elements = [Element(str(year), 'Numeric') for year in range(1990, 2041, 1)]
hierarchy = Hierarchy('TM1py Year', 'TM1py Year', elements)
dimension = Dimension('TM1py Year', [hierarchy])
if not tm1.dimensions.exists(dimension.name):
tm1.dimensions.create(dimension)
# create dimension TM1py FX Rates Measure
elements = [
Element('Spot', 'Numeric'),
Element('EOP', 'Numeric'),
Element('AVG', 'Numeric'),
Element('Month Close', 'Numeric')
]
hierarchy = Hierarchy('TM1py FX Rates Measure', 'TM1py FX Rates Measure',
elements)
dimension = Dimension('TM1py FX Rates Measure', [hierarchy])
if not tm1.dimensions.exists(dimension.name):
tm1.dimensions.create(dimension)
# create cube TM1py FX Rates
cube = Cube('ECB TM1py FX Rates', [
'TM1py Currency From', 'TM1py Currency To', 'TM1py Date',
'TM1py FX Rates Measure'
])
if not tm1.cubes.exists(cube.name):
tm1.cubes.create(cube)
# create dimension TM1py FX Rates Measure
elements = [
Element('Spot', 'Numeric'),
Element('EOP', 'Numeric'),
Element('AVG', 'Numeric'),
Element('Month Close', 'Numeric')
]
hierarchy = Hierarchy('TM1py FX Rates Measure', 'TM1py FX Rates Measure',
elements)
dimension = Dimension('TM1py FX Rates Measure', [hierarchy])
if not tm1.dimensions.exists(dimension.name):
tm1.dimensions.create(dimension)
# create cube TM1py FX Rates
cube = Cube('TM1py FX Rates', [
'TM1py Currency From', 'TM1py Currency To', 'TM1py Date',
'TM1py FX Rates Measure'
])
if not tm1.cubes.exists(cube.name):
tm1.cubes.create(cube)
# create cube TM1py FX Rates Monthly
cube = Cube('TM1py FX Rates Monthly', [
'TM1py Currency From', 'TM1py Currency To', 'TM1py Year',
'TM1py Month', 'TM1py FX Rates Measure'
])
if not tm1.cubes.exists(cube.name):
tm1.cubes.create(cube)
# ============================
# create TM1 objects for gdp sample
def setup_class(cls):
# Connection to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# generate random coordinates
cls.target_coordinates = list(
zip(('Element ' + str(random.randint(1, 1000))
for _ in range(100)),
('Element ' + str(random.randint(1, 1000))
for _ in range(100)),
('Element ' + str(random.randint(1, 1000))
for _ in range(100))))
# 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)
attribute_cube = "}ElementAttributes_" + dimension_name
attribute_values = dict()
for element in elements:
attribute_values[(element.name, "Attr1")] = "TM1py"
attribute_values[(element.name, "Attr2")] = "2"
attribute_values[(element.name, "Attr3")] = "3"
cls.tm1.cubes.cells.write_values(attribute_cube, attribute_values)
# 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}'))
cls.tm1.cubes.views.create(view=view, private=False)
# Sum of all the values that we write in the cube. serves as a checksum.
cls.total_value = 0
# cellset of data that shall be written
cls.cellset = {}
for element1, element2, element3 in cls.target_coordinates:
value = random.randint(1, 1000)
cls.cellset[(element1, element2, element3)] = value
# update the checksum
cls.total_value += value
# Fill cube with values
cls.tm1.cubes.cells.write_values(CUBE_NAME, cls.cellset)