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'])
cls.user_name = PREFIX + "Us'er1"
cls.user_name_exotic_password = "******"
cls.enabled = True
cls.user = User(name=cls.user_name,
groups=[],
password='******',
enabled=cls.enabled)
cls.group_name1 = PREFIX + "Gro'up1"
cls.group_name2 = PREFIX + "Group2"
cls.user.add_group(cls.group_name1)
if cls.user_name in CaseAndSpaceInsensitiveSet(
*cls.tm1.security.get_all_user_names()):
cls.tm1.security.delete_user(cls.user_name)
for group in (cls.group_name1, cls.group_name2):
if group in CaseAndSpaceInsensitiveSet(
*cls.tm1.security.get_all_groups()):
cls.tm1.security.delete_group(group)
def update(self, dimension: Dimension, **kwargs):
""" Update an existing dimension
:param dimension: instance of TM1py.Dimension
:return: None
"""
# delete hierarchies that have been removed from the dimension object
hierarchies_to_be_removed = CaseAndSpaceInsensitiveSet(
*self.hierarchies.get_all_names(dimension.name, **kwargs))
for hierarchy in dimension.hierarchy_names:
hierarchies_to_be_removed.discard(hierarchy)
for hierarchy_name in hierarchies_to_be_removed:
self.hierarchies.delete(dimension_name=dimension.name,
hierarchy_name=hierarchy_name,
**kwargs)
# update all Hierarchies except for the implicitly maintained 'Leaves' Hierarchy
for hierarchy in dimension:
if not case_and_space_insensitive_equals(hierarchy.name, "Leaves"):
if self.hierarchies.exists(hierarchy.dimension_name,
hierarchy.name, **kwargs):
self.hierarchies.update(hierarchy, **kwargs)
else:
self.hierarchies.create(hierarchy, **kwargs)
def __init__(self,
name: str,
groups: Iterable[str],
friendly_name: Optional[str] = None,
password: Optional[str] = None,
user_type: Union[UserType, str] = None,
enabled: bool = None):
self._name = name
self._groups = CaseAndSpaceInsensitiveSet(*groups)
self._friendly_name = friendly_name
self._password = password
self._enabled = enabled
self._user_type = user_type
# determine user_type
if user_type is None:
if str(UserType.Admin) in self._groups:
self.user_type = UserType.Admin
elif str(UserType.SecurityAdmin) in self._groups:
self.user_type = UserType.SecurityAdmin
elif str(UserType.DataAdmin) in self._groups:
self.user_type = UserType.DataAdmin
elif str(UserType.OperationsAdmin) in self._groups:
self.user_type = UserType.OperationsAdmin
else:
self.user_type = UserType.User
else:
self.user_type = user_type
def test_create_and_delete_user(self):
u = User(name=PREFIX + "User2", groups=())
all_users = self.tm1.security.get_all_user_names()
if u.name not in CaseAndSpaceInsensitiveSet(*all_users):
self.tm1.security.create_user(u)
users_before_delete = self.tm1.security.get_all_user_names()
response = self.tm1.security.delete_user(u.name)
self.assertTrue(response.ok)
users_after_delete = self.tm1.security.get_all_user_names()
self.assertIn(u.name, CaseAndSpaceInsensitiveSet(*users_before_delete))
self.assertNotIn(u.name, CaseAndSpaceInsensitiveSet(*users_after_delete))
def setup_class(cls):
cls.tm1 = TM1Service(**config['tm1srv01'])
cls.user_name = PREFIX + "Us'er1"
cls.user = User(name=cls.user_name, groups=[], password='******')
cls.group_name1 = PREFIX + "Gro'up1"
cls.group_name2 = PREFIX + "Group2"
cls.user.add_group(cls.group_name1)
if cls.user_name in CaseAndSpaceInsensitiveSet(*cls.tm1.security.get_all_user_names()):
cls.tm1.security.delete_user(cls.user_name)
for group in (cls.group_name1, cls.group_name2):
if group in CaseAndSpaceInsensitiveSet(*cls.tm1.security.get_all_groups()):
cls.tm1.security.delete_group(group)
def update_element_attributes(self, hierarchy: Hierarchy, **kwargs):
""" Update the elementattributes of a hierarchy
:param hierarchy: Instance of TM1py.Hierarchy
:return:
"""
# get existing attributes first
existing_element_attributes = self.elements.get_element_attributes(
dimension_name=hierarchy.dimension_name,
hierarchy_name=hierarchy.name,
**kwargs)
existing_element_attributes = CaseAndSpaceInsensitiveDict(
{ea.name: ea
for ea in existing_element_attributes})
attributes_to_create = list()
attributes_to_delete = list()
attributes_to_update = list()
for element_attribute in hierarchy.element_attributes:
if element_attribute.name not in existing_element_attributes:
attributes_to_create.append(element_attribute)
continue
existing_element_attribute = existing_element_attributes[
element_attribute.name]
if not existing_element_attribute.attribute_type == element_attribute.attribute_type:
attributes_to_update.append(element_attribute)
continue
for existing_element_attribute in existing_element_attributes:
if existing_element_attribute not in CaseAndSpaceInsensitiveSet(
[ea.name for ea in hierarchy.element_attributes]):
attributes_to_delete.append(existing_element_attribute)
for element_attribute in attributes_to_create:
self.elements.create_element_attribute(
dimension_name=hierarchy.dimension_name,
hierarchy_name=hierarchy.name,
element_attribute=element_attribute,
**kwargs)
for element_attribute in attributes_to_delete:
self.elements.delete_element_attribute(
dimension_name=hierarchy.dimension_name,
hierarchy_name=hierarchy.name,
element_attribute=element_attribute,
**kwargs)
for element_attribute in attributes_to_update:
self.elements.delete_element_attribute(
dimension_name=hierarchy.dimension_name,
hierarchy_name=hierarchy.name,
element_attribute=element_attribute.name,
**kwargs)
self.elements.create_element_attribute(
dimension_name=hierarchy.dimension_name,
hierarchy_name=hierarchy.name,
element_attribute=element_attribute,
**kwargs)
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'])
if cls.user_name in CaseAndSpaceInsensitiveSet(
*cls.tm1.security.get_all_user_names()):
cls.tm1.security.delete_user(cls.user_name)
for group in (cls.group_name1, cls.group_name2):
if group in CaseAndSpaceInsensitiveSet(
*cls.tm1.security.get_all_groups()):
cls.tm1.security.delete_group(group)
def update(self, dimension: Dimension, **kwargs):
""" Update an existing dimension
:param dimension: instance of TM1py.Dimension
:return: None
"""
# delete hierarchies that have been removed from the dimension object
hierarchies_to_be_removed = CaseAndSpaceInsensitiveSet(
*self.hierarchies.get_all_names(dimension.name, **kwargs))
for hierarchy in dimension.hierarchy_names:
hierarchies_to_be_removed.discard(hierarchy)
# update all Hierarchies except for the implicitly maintained 'Leaves' Hierarchy
for hierarchy in dimension:
if not case_and_space_insensitive_equals(hierarchy.name, "Leaves"):
if self.hierarchies.exists(hierarchy.dimension_name,
hierarchy.name, **kwargs):
self.hierarchies.update(hierarchy, **kwargs)
else:
self.hierarchies.create(hierarchy, **kwargs)
# Edge case: elements in leaves hierarchy that do not exist in other hierarchies
if "Leaves" in dimension:
existing_leaves = CaseAndSpaceInsensitiveSet(
self.hierarchies.elements.get_leaf_element_names(
dimension.name, "Leaves"))
leaves_to_create = list()
for leaf in dimension.get_hierarchy("Leaves"):
if leaf.name not in existing_leaves:
leaves_to_create.append(leaf)
if leaves_to_create:
self.hierarchies.elements.add_elements(
dimension_name=dimension.name,
hierarchy_name="Leaves",
elements=leaves_to_create)
for hierarchy_name in hierarchies_to_be_removed:
if not case_and_space_insensitive_equals(hierarchy_name, "Leaves"):
self.hierarchies.delete(dimension_name=dimension.name,
hierarchy_name=hierarchy_name,
**kwargs)
def test_create_and_delete_group(self):
group = PREFIX + "Group3"
groups = self.tm1.security.get_all_groups()
if group not in CaseAndSpaceInsensitiveSet(*groups):
self.tm1.security.create_group(group)
groups_before_delete = self.tm1.security.get_all_groups()
response = self.tm1.security.delete_group(group)
self.assertTrue(response.ok)
groups_after_delete = self.tm1.security.get_all_groups()
self.assertIn(group, groups_before_delete)
self.assertNotIn(group, groups_after_delete)
def test_get_custom_security_groups(self):
custom_groups = self.tm1.security.get_custom_security_groups()
self.assertNotIn("Admin", CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertNotIn("DataAdmin", CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertNotIn("SecurityAdmin", CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertNotIn("OperationsAdmin", CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertNotIn("}tp_Everyone", CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertIn(self.group_name1, CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertIn(self.group_name2, CaseAndSpaceInsensitiveSet(*custom_groups))
self.assertNotIn("NotExistingGroup", CaseAndSpaceInsensitiveSet(*custom_groups))
def write_to_message_log(self, level: str, message: str, **kwargs) -> None:
"""
:param level: string, FATAL, ERROR, WARN, INFO, DEBUG
:param message: string
:return:
"""
valid_levels = CaseAndSpaceInsensitiveSet(
{'FATAL', 'ERROR', 'WARN', 'INFO', 'DEBUG'})
if level not in valid_levels:
raise ValueError(f"Invalid level: '{level}'")
from TM1py.Services import ProcessService
process_service = ProcessService(self._rest)
process = Process(name="",
prolog_procedure="LogOutput('{}', '{}');".format(
level, message))
success, status, _ = process_service.execute_process_with_return(
process, **kwargs)
if not success:
raise RuntimeError(
f"Failed to write to TM1 Message Log through unbound process. Status: '{status}'"
)
def get_custom_security_groups(self, **kwargs) -> List[str]:
custom_groups = CaseAndSpaceInsensitiveSet(*self.get_all_groups(
**kwargs))
custom_groups.discard('Admin')
custom_groups.discard('DataAdmin')
custom_groups.discard('SecurityAdmin')
custom_groups.discard('OperationsAdmin')
custom_groups.discard('}tp_Everyone')
return list(custom_groups)
class User(TM1Object):
""" Abstraction of a TM1 User
"""
def __init__(self,
name: str,
groups: Iterable[str],
friendly_name: Optional[str] = None,
password: Optional[str] = None,
user_type: Union[UserType, str] = None,
enabled: bool = None):
self._name = name
self._groups = CaseAndSpaceInsensitiveSet(*groups)
self._friendly_name = friendly_name
self._password = password
self._enabled = enabled
self._user_type = user_type
# determine user_type
if user_type is None:
if str(UserType.Admin) in self._groups:
self.user_type = UserType.Admin
elif str(UserType.SecurityAdmin) in self._groups:
self.user_type = UserType.SecurityAdmin
elif str(UserType.DataAdmin) in self._groups:
self.user_type = UserType.DataAdmin
elif str(UserType.OperationsAdmin) in self._groups:
self.user_type = UserType.OperationsAdmin
else:
self.user_type = UserType.User
else:
self.user_type = user_type
@property
def name(self) -> str:
return self._name
@property
def user_type(self) -> UserType:
return self._user_type
@property
def friendly_name(self) -> str:
return self._friendly_name
@property
def password(self) -> str:
if self._password:
return self._password
@property
def is_admin(self) -> bool:
return 'ADMIN' in self.groups
@property
def groups(self) -> List[str]:
return [group for group in self._groups]
@property
def enabled(self) -> bool:
return self._enabled
@name.setter
def name(self, value: str):
self._name = value
@friendly_name.setter
def friendly_name(self, value: str):
self._friendly_name = value
@password.setter
def password(self, value: str):
self._password = value
@enabled.setter
def enabled(self, value: Union[bool, None]):
self._enabled = value
@user_type.setter
def user_type(self, value: Union[str, UserType]):
if not isinstance(value, str) and not isinstance(value, UserType):
raise ValueError(
"argument 'user_type' must be of type str or UserType")
self._user_type = UserType(value)
# update groups as well, since TM1 doesn't react to change in user_type property
if self._user_type is not UserType.User:
self.add_group(str(self._user_type))
def add_group(self, group_name: str):
self._groups.add(group_name)
def remove_group(self, group_name: str):
self._groups.discard(group_name)
@classmethod
def from_json(cls, user_as_json: str):
""" Alternative constructor
:param user_as_json: user as JSON string
:return: user, an instance of this class
"""
user_as_dict = json.loads(user_as_json)
return cls.from_dict(user_as_dict)
@classmethod
def from_dict(cls, user_as_dict: Dict) -> 'User':
""" Alternative constructor
:param user_as_dict: user as dict
:return: user, an instance of this class
"""
return cls(name=user_as_dict['Name'],
friendly_name=user_as_dict['FriendlyName'],
enabled=user_as_dict["Enabled"],
user_type=user_as_dict["Type"],
groups=[group["Name"] for group in user_as_dict['Groups']])
@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 user
"""
body_as_dict = collections.OrderedDict()
body_as_dict['Name'] = self.name
body_as_dict['FriendlyName'] = self.friendly_name or self.name
body_as_dict['Enabled'] = self._enabled
body_as_dict['Type'] = str(self._user_type)
if self.password:
body_as_dict['Password'] = self._password
body_as_dict['*****@*****.**'] = [
format_url("Groups('{}')", group) for group in self.groups
]
return json.dumps(body_as_dict, ensure_ascii=False)
class User(TM1Object):
""" Abstraction of a TM1 User
"""
def __init__(self, name, groups, friendly_name=None, password=None):
self._name = name
self._groups = CaseAndSpaceInsensitiveSet(*groups)
self._friendly_name = friendly_name
self._password = password
@property
def name(self):
return self._name
@property
def friendly_name(self):
return self._friendly_name
@property
def password(self):
if self._password:
return self._password
@property
def is_admin(self):
return 'ADMIN' in self.groups
@property
def groups(self):
return [group for group in self._groups]
@name.setter
def name(self, value):
self._name = value
@friendly_name.setter
def friendly_name(self, value):
self._friendly_name = value
@password.setter
def password(self, value):
self._password = value
def add_group(self, group_name):
self._groups.add(group_name)
def remove_group(self, group_name):
self._groups.discard(group_name)
@classmethod
def from_json(cls, user_as_json):
""" Alternative constructor
:param user_as_json: user as JSON string
:return: user, an instance of this class
"""
user_as_dict = json.loads(user_as_json)
return cls.from_dict(user_as_dict)
@classmethod
def from_dict(cls, user_as_dict):
""" Alternative constructor
:param user_as_dict: user as dict
:return: user, an instance of this class
"""
return cls(name=user_as_dict['Name'],
friendly_name=user_as_dict['FriendlyName'],
groups=[group["Name"] for group in user_as_dict['Groups']])
@property
def body(self):
return self.construct_body()
def construct_body(self):
"""
construct body (json) from the class attributes
:return: String, TM1 JSON representation of a user
"""
body_as_dict = collections.OrderedDict()
body_as_dict['Name'] = self.name
body_as_dict['FriendlyName'] = self.friendly_name
if self.password:
body_as_dict['Password'] = self._password
body_as_dict['*****@*****.**'] = [
'Groups(\'{}\')'.format(group) for group in self.groups
]
return json.dumps(body_as_dict, ensure_ascii=False)
def test_ne(self):
new_set = CaseAndSpaceInsensitiveSet()
new_set.add("wrong1")
new_set.add("wrong2")
new_set.add("wrong3")
self.assertNotEqual(self.set, new_set)
def test_eq_case_and_space_sensitivity(self):
new_set = CaseAndSpaceInsensitiveSet()
new_set.add(self.original_values[0].upper())
new_set.add(self.original_values[1].lower())
new_set.add(self.original_values[2].lower())
self.assertEqual(self.set, new_set)
def test_eq(self):
new_set = CaseAndSpaceInsensitiveSet()
new_set.add(self.original_values[0])
new_set.add(self.original_values[1])
new_set.add(self.original_values[2])
self.assertEqual(self.set, new_set)
def build_dimensions(tm1: TM1Service, loans: list):
dimension_name = "Time"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for year in range(2005, 2020, 1):
hierarchy.add_element(element_name=str(year),
element_type="Consolidated")
hierarchy.add_edge(parent=total_element, component=str(year), weight=1)
for month in ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"):
hierarchy.add_element(element_name="{}-{}".format(
month, str(year)),
element_type="Numeric")
hierarchy.add_edge(parent=str(year),
component="{}-{}".format(month, str(year)),
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Loan"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
dimension.add_hierarchy(hierarchy)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
element_names = [loan.loan_id for loan in loans]
# send elements and edges separately to avoid strange firewall connection abortion from server side
for element_name in element_names:
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
update_or_create_dimension(tm1, dimension)
for element_name in element_names:
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
update_or_create_dimension(tm1, dimension)
dimension_name = "LC Rating"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for rating in ("A", "B", "C", "D", "E", "F", "G"):
element_name = rating
hierarchy.add_element(element_name=element_name,
element_type="Consolidated")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
for sub_rating in ("1", "2", "3", "4", "5"):
element_name = rating + sub_rating
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=rating, component=element_name, weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "FICO Score"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in range(300, 851, 1):
hierarchy.add_element(element_name=str(element_name),
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=str(element_name),
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Employment"
if tm1.dimensions.exists(dimension_name=dimension_name):
dimension = tm1.dimensions.get(dimension_name=dimension_name)
else:
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
if hierarchy_name in dimension:
hierarchy = dimension.get_hierarchy(hierarchy_name=hierarchy_name)
else:
hierarchy = Hierarchy(name=hierarchy_name,
dimension_name=dimension_name)
dimension.add_hierarchy(hierarchy)
total_element = "Total " + dimension_name
if total_element not in hierarchy.elements:
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
employments = CaseAndSpaceInsensitiveSet()
for loan in loans:
employments.add(loan.emp_title)
employments.add("None")
for employment in employments:
if employment and employment not in hierarchy.elements:
employment = employment.strip()
hierarchy.add_element(element_name=employment,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=employment,
weight=1)
update_or_create_dimension(tm1, dimension)
dimension_name = "Term"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("36 months", "60 months"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Income"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("10000", "20000", "30000", "40000", "50000", "60000",
"70000", "80000", "90000", "100000", "110000",
"120000", "130000", "140000", "150000", "160000",
"170000", "180000", "190000"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Purpose"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("other", "debt_consolidation", "medical",
"major_purchase", "home_improvement", "credit_card",
"vacation", "house", "car", "small_business",
"moving", "renewable_energy", "wedding",
"educational"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Loan Status"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("Current", "Fully Paid", "Late (31-120 days)",
"Late (16-30 days)", "Charged Off", "In Grace Period",
"Default"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "State"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
states = CaseAndSpaceInsensitiveSet()
for loan in loans:
states.add(loan.addr_state)
states.add("None")
for state in states:
if state:
state = state.strip()
hierarchy.add_element(element_name=state, element_type="Numeric")
hierarchy.add_edge(parent=total_element, component=state, weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Home Ownership"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("Rent", "Own", "Mortgage", "Any", "None"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Application Type"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in ("Individual", "Joint App"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Income To Loan Ratio"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for counter in range(0, 100000, 1):
dti = counter / 100
element_name = "%.2f" % dti
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=element_name,
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = "Delinquency Events"
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
total_element = "Total " + dimension_name
hierarchy.add_element(element_name=total_element,
element_type="Consolidated")
for element_name in range(0, 51):
hierarchy.add_element(element_name=str(element_name),
element_type="Numeric")
hierarchy.add_edge(parent=total_element,
component=str(element_name),
weight=1)
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
dimension_name = " ".join([CUBE_NAME, "Measure"])
dimension = Dimension(name=dimension_name)
hierarchy_name = dimension_name
hierarchy = Hierarchy(name=hierarchy_name, dimension_name=dimension_name)
for element_name in ("loan_amnt", "int_rate", "installment", "out_prncp",
"total_pymnt", "last_pymnt_amnt",
"total_pymnt_by_loan_amnt", "emp_length",
"num_personal_inquiries", "inquiries_in_last_12m",
"mths_since_last_delinq", "mths_since_recent_bc_dlq",
"mths_since_recent_inq",
"mths_since_recent_revol_delinq", "defaulted",
"defaulted_or_delayed"):
hierarchy.add_element(element_name=element_name,
element_type="Numeric")
for element_name in ("last_pymnt_d", ):
hierarchy.add_element(element_name=element_name, element_type="String")
hierarchy.add_element_attribute(name="Description", attribute_type="Alias")
dimension.add_hierarchy(hierarchy)
update_or_create_dimension(tm1, dimension)
attributes = {
("loan_amnt", "Description"): "Listed amount of the loan",
("int_rate", "Description"): "Interest rate",
("installment", "Description"): "Monthly payment",
("out_prncp", "Description"): "Remaining outstanding amount",
("total_pymnt", "Description"): "Payments received to date",
("total_pymnt_by_loan_amnt", "Description"):
"Total Payments devided by total Loan",
("last_pymnt_amnt", "Description"): "Last payment amount received",
("last_pymnt_d", "Description"): "Last month payment was received",
("defaulted", "Description"): "Loan is defaulted"
}
tm1.cubes.cells.write_values(cube_name="}ElementAttributes_" +
dimension_name,
cellset_as_dict=attributes)
def __init__(self, name, groups, friendly_name=None, password=None):
self._name = name
self._groups = CaseAndSpaceInsensitiveSet(*groups)
self._friendly_name = friendly_name
self._password = password
def setUp(cls):
cls.original_values = ("Value1", "Value 2", "V A L U E 3")
cls.set = CaseAndSpaceInsensitiveSet()
cls.set.add(cls.original_values[0])
cls.set.add(cls.original_values[1])
cls.set.add(cls.original_values[2])
def is_admin(self) -> bool:
return "ADMIN" in CaseAndSpaceInsensitiveSet(*self.groups)