def _construct_attribute_context_tree(
self,
proj_ctx: 'ProjectionContext',
set_attr_ctx: Optional[bool] = False) -> None:
"""
Takes all the stored attribute context parameters, creates attribute contexts from them, and then constructs the tree.
:param proj_ctx: The projection context
:param set_attr_ctx: Whether to set the created attribute context on the associated resolved attribute
"""
# Iterate over all the search_for attribute context parameters
for search_for_attr_ctx_param in self._search_for_to_search_for_attr_ctx_param.values(
):
search_for_attr_ctx = None
# Fetch all the found attribute context parameters associated with this search_for
found_attr_ctx_params = self._search_for_attr_ctx_param_to_found_attr_ctx_param[
search_for_attr_ctx_param]
# Iterate over all the found attribute context parameters
for found_attr_ctx_param in found_attr_ctx_params:
# We should only create the search_for node when search_for and found have different names. Else collapse the nodes together.
if not StringUtils.equals_with_case(
search_for_attr_ctx_param._name,
found_attr_ctx_param._name):
# Create the attribute context for searchFor if it hasn't been created already and set it as the parent of found
if search_for_attr_ctx is None:
search_for_attr_ctx = CdmAttributeContext._create_child_under(
proj_ctx._projection_directive._res_opt,
search_for_attr_ctx_param)
found_attr_ctx_param._under = search_for_attr_ctx
# Fetch the action attribute context parameter associated with this found
action_attr_ctx_param = self._found_attr_ctx_param_to_action_attr_ctx_param[
found_attr_ctx_param]
# We should only create the found node when found and action have different names. Else collapse the nodes together.
if not StringUtils.equals_with_case(
found_attr_ctx_param._name,
action_attr_ctx_param._name):
# Create the attribute context for found and set it as the parent of action
found_attr_ctx = CdmAttributeContext._create_child_under(
proj_ctx._projection_directive._res_opt,
found_attr_ctx_param)
action_attr_ctx_param._under = found_attr_ctx
# Create the attribute context for action
action_attr_ctx = CdmAttributeContext._create_child_under(
proj_ctx._projection_directive._res_opt,
action_attr_ctx_param)
# Fetch the resolved attribute that should now point at this action attribute context
res_attr_from_action = self._action_attr_ctx_param_to_res_attr[
action_attr_ctx_param]
# TODO (jibyun): For now, only set the created attribute context on the resolved attribute when specified to,
# as pointing the resolved attribute at this attribute context won't work currently for certain operations (Include/Exclude).
# This will be changed to always run once we work on the attribute context fix.
if set_attr_ctx:
res_attr_from_action.att_ctx = action_attr_ctx
def to_data(instance: CdmImport, res_opt: ResolveOptions,
options: CopyOptions) -> Import:
result = Import()
if not StringUtils.is_blank_by_cdm_standard(instance.corpus_path):
result.corpusPath = instance.corpus_path
if not StringUtils.is_blank_by_cdm_standard(instance.moniker):
result.moniker = instance.moniker
return result
def create_adapter_with_shared_key(self, root_relative_path: str = None):
hostname = os.environ.get("ADLS_HOSTNAME")
root_path = os.environ.get("ADLS_ROOTPATH")
shared_key = os.environ.get("ADLS_SHAREDKEY")
self.assertFalse(StringUtils.is_null_or_white_space(hostname), "ADLS_HOSTNAME environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(root_path), "ADLS_ROOTPATH environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(shared_key), "ADLS_SHAREDKEY environment variable not set up")
adapter = ADLSAdapter(hostname=hostname, root=self.combine_path(root_path, root_relative_path), shared_key=shared_key)
return adapter
def _get_new_attribute_name(self, attribute_state: 'ProjectionAttributeState', source_attribute_name: str):
current_attribute_name = attribute_state._current_resolved_attribute._resolved_name
ordinal = str(attribute_state._ordinal) if attribute_state._ordinal is not None else ''
if not self.rename_format:
logger.error(self._TAG, self.ctx, 'RenameFormat should be set for this operation to work.')
return ''
attribute_name = StringUtils._replace(self.rename_format, 'a', source_attribute_name)
attribute_name = StringUtils._replace(attribute_name, 'o', ordinal)
attribute_name = StringUtils._replace(attribute_name, 'm', current_attribute_name)
return attribute_name
def create_adapter_with_client_id(self, root_relative_path: str = None):
hostname = os.environ.get("ADLS_HOSTNAME")
root_path = os.environ.get("ADLS_ROOTPATH")
tenant = os.environ.get("ADLS_TENANT")
client_id = os.environ.get("ADLS_CLIENTID")
client_secret = os.environ.get("ADLS_CLIENTSECRET")
self.assertFalse(StringUtils.is_null_or_white_space(hostname), "ADLS_HOSTNAME environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(root_path), "ADLS_ROOTPATH environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(tenant), "ADLS_TENANT environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(client_id), "ADLS_CLIENTID environment variable not set up")
self.assertFalse(StringUtils.is_null_or_white_space(client_secret), "ADLS_CLIENTSECRET environment variable not set up")
adapter = ADLSAdapter(hostname=hostname, root=self.combine_path(root_path, root_relative_path), tenant=tenant, client_id=client_id, secret=client_secret)
return adapter
def from_data(
ctx: 'CdmCorpusContext', data: 'OperationCombineAttributes'
) -> 'CdmOperationCombineAttributes':
if not data:
return None
combine_attributes_op = ctx.corpus.make_object(
CdmObjectType.OPERATION_COMBINE_ATTRIBUTES_DEF)
if data.type and not StringUtils.equals_with_ignore_case(
data.type,
OperationTypeConvertor._operation_type_to_string(
CdmOperationType.COMBINE_ATTRIBUTES)):
logger.error(
_TAG, ctx,
'$type {} is invalid for this operation.'.format(data.type))
else:
combine_attributes_op.type = CdmOperationType.COMBINE_ATTRIBUTES
if data.explanation:
combine_attributes_op.explanation = data.explanation
combine_attributes_op.take = data.take
combine_attributes_op.merge_into = utils.create_attribute(
ctx, data.mergeInto)
return combine_attributes_op
async def from_data(
ctx: 'CdmCorpusContext', data: 'LocalEntity',
extension_trait_def_list: List['CdmTraitDefinition'],
local_extension_trait_def_list: List['CdmTraitDefinition']
) -> Optional['CdmEntityDefinition']:
entity = ctx.corpus.make_object(CdmObjectType.ENTITY_DEF, data.name)
if not StringUtils.is_blank_by_cdm_standard(data.get('description')):
entity.description = data.description
await utils.process_annotations_from_data(ctx, data,
entity.exhibits_traits)
for element in (data.get('attributes') or []):
type_attribute = await TypeAttributePersistence.from_data(
ctx, element, extension_trait_def_list,
local_extension_trait_def_list)
if type_attribute is not None:
entity.attributes.append(type_attribute)
else:
logger.error(
ctx, EntityPersistence.__name__,
EntityPersistence.from_data.__name__,
element.at_corpus_path, CdmLogCode.
ERR_PERSIST_MODELJSON_TO_ATTR_CONVERSION_FAILURE)
return
extension_helper.process_extension_from_json(
ctx, data, entity.exhibits_traits, extension_trait_def_list,
local_extension_trait_def_list)
return entity
def update_config(self, config: str):
configs_json = json.loads(config)
if configs_json.get('root'):
self.root = configs_json['root']
else:
raise ValueError('Root has to be set for ADLS adapter.')
if configs_json.get('hostname'):
self.hostname = configs_json['hostname']
else:
raise ValueError('Hostname has to be set for ADLS adapter.')
self.update_network_config(config)
if configs_json.get('tenant') and configs_json.get('clientId'):
self._tenant = configs_json['tenant']
self.client_id = configs_json['clientId']
# To keep backwards compatibility with config files that were generated before the introduction of the `endpoint` property.
if not hasattr(self, 'endpoint') or not self.endpoint:
self.endpoint = AzureCloudEndpoint.AZURE_PUBLIC
if configs_json.get('locationHint'):
self.location_hint = configs_json['locationHint']
if configs_json.get('endpoint'):
endpoint_from_config = StringUtils.pascal_case_to_snake_case(
configs_json['endpoint'])
if endpoint_from_config in AzureCloudEndpoint.__members__.keys():
self.endpoint = AzureCloudEndpoint[endpoint_from_config]
else:
raise ValueError(
'Endpoint value should be a string of an enumeration value from the class AzureCloudEndpoint in Pascal case.'
)
def from_data(
ctx: 'CdmCorpusContext',
data: 'OperationArrayExpansion') -> 'CdmOperationArrayExpansion':
if not data:
return None
array_expansion_op = ctx.corpus.make_object(
CdmObjectType.OPERATION_ARRAY_EXPANSION_DEF)
if data.type and not StringUtils.equals_with_ignore_case(
data.type,
OperationTypeConvertor._operation_type_to_string(
CdmOperationType.ARRAY_EXPANSION)):
logger.error(
_TAG, ctx,
'$type {} is invalid for this operation.'.format(data.type))
else:
array_expansion_op.type = CdmOperationType.ARRAY_EXPANSION
if data.explanation:
array_expansion_op.explanation = data.explanation
array_expansion_op.start_ordinal = data.startOrdinal
array_expansion_op.end_ordinal = data.endOrdinal
return array_expansion_op
def _build_structure(curr: 'ProjectionAttributeState',
top: 'ProjectionAttributeState', attr_name: str,
st: 'SearchStructure', found_flag: bool,
found_depth: int) -> 'SearchStructure':
"""Build a structure using a stack"""
if curr:
st._add(curr)
if StringUtils.equals_with_case(
curr._current_resolved_attribute.resolved_name, attr_name):
found_flag = True
st._result.found_flag = True
st._result.found_depth = found_depth
st._result.found = curr
if found_flag and (curr and
(curr._previous_state_list is None or
(curr._previous_state_list is not None
and len(curr._previous_state_list) == 0))):
st._result.leaf.append(curr)
if curr._previous_state_list and len(
curr._previous_state_list) > 0:
for prev in curr._previous_state_list:
SearchStructure._build_structure(prev, top, attr_name, st,
found_flag,
found_depth + 1)
return st
def from_data(ctx: 'CdmCorpusContext', object_type: 'CdmObjectType',
data: 'OperationBase'):
if data is None:
return None
operation = ctx.corpus.make_object(
object_type) # type: CdmOperationBase
operation_type = OperationTypeConvertor._from_object_type(
object_type) # type: CdmOperationType
operation_name = OperationTypeConvertor._operation_type_to_string(
CdmOperationType.COMBINE_ATTRIBUTES)
if data.type and not StringUtils.equals_with_ignore_case(
data.type, operation_name):
logger.error(ctx, operation_name,
OperationBasePersistence.from_data.__name__, None,
CdmLogCode.ERR_PERSIST_PROJ_INVALID_OPS_TYPE,
data.type)
else:
operation.type = operation_type
operation.condition = data.condition
operation.explanation = data.explanation
operation.source_input = data.sourceInput
return operation
def fetch_config(self) -> str:
result_config = {'type': self._type}
config_object = {
'hostname': self.hostname,
'root': self.root
}
# Check for clientId auth, we won't write shared key or secrets to JSON.
if self.client_id and self.tenant:
config_object['tenant'] = self.tenant
config_object['clientId'] = self.client_id
# Try constructing network configs.
config_object.update(self.fetch_network_config())
if self.location_hint:
config_object['locationHint'] = self.location_hint
if self.endpoint:
config_object['endpoint'] = StringUtils.snake_case_to_pascal_case(self.endpoint.name)
result_config['config'] = config_object
return json.dumps(result_config)
def from_data(
ctx: 'CdmCorpusContext', data: 'OperationAddSupportingAttribute'
) -> 'CdmOperationAddSupportingAttribute':
if not data:
return None
add_supporting_attribute_op = ctx.corpus.make_object(
CdmObjectType.OPERATION_ADD_SUPPORTING_ATTRIBUTE_DEF)
if data.type and not StringUtils.equals_with_ignore_case(
data.type,
OperationTypeConvertor._operation_type_to_string(
CdmOperationType.ADD_SUPPORTING_ATTRIBUTE)):
logger.error(
_TAG, ctx,
'$type {} is invalid for this operation.'.format(data.type))
else:
add_supporting_attribute_op.type = CdmOperationType.ADD_SUPPORTING_ATTRIBUTE
if data.explanation:
add_supporting_attribute_op.explanation = data.explanation
if data.supportingAttribute:
add_supporting_attribute_op.supporting_attribute = utils.create_attribute(
ctx, data.supportingAttribute)
return add_supporting_attribute_op
def from_data(
ctx: 'CdmCorpusContext', data: 'OperationIncludeAttributes'
) -> 'CdmOperationIncludeAttributes':
if not data:
return None
include_attributes_op = ctx.corpus.make_object(
CdmObjectType.OPERATION_INCLUDE_ATTRIBUTES_DEF)
if data.type and not StringUtils.equals_with_ignore_case(
data.type,
OperationTypeConvertor._operation_type_to_string(
CdmOperationType.INCLUDE_ATTRIBUTES)):
logger.error(
_TAG, ctx,
'$type {} is invalid for this operation.'.format(data.type))
else:
include_attributes_op.type = CdmOperationType.INCLUDE_ATTRIBUTES
if data.explanation:
include_attributes_op.explanation = data.explanation
include_attributes_op.include_attributes = data.includeAttributes
return include_attributes_op
async def test_model_json_data_partition_location_consistency(self):
'''
Testing whether DataPartition Location is consistently populated when:
1. Manifest is read directly.
2. Manifest is obtained by converting a model.json.
'''
test_name = 'test_model_json_data_partition_location_consistency'
test_name_in_pascal_case = StringUtils.snake_case_to_pascal_case(test_name)
cdm_corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
manifest_read = await cdm_corpus.fetch_object_async('default.manifest.cdm.json', cdm_corpus.storage.fetch_root_folder('local'))
self.assertEqual('EpisodeOfCare/partition-data.csv', manifest_read.entities[0].data_partitions[0].location)
converted_to_model_json = await ManifestPersistence.to_data(manifest_read, None, None)
location = converted_to_model_json.entities[0]['partitions'][0]['location'] # type: str
location_path = os.path.join('TestData', 'Persistence', 'ModelJson', 'DataPartition', test_name_in_pascal_case, 'Input', 'EpisodeOfCare', 'partition-data.csv')
# Model Json uses absolute adapter path.
self.assertTrue(location.find(location_path) != -1)
cdm_corpus2 = TestHelper.get_local_corpus(self.tests_subpath, test_name)
manifest_after_convertion = await ManifestPersistence.from_object(cdm_corpus2.ctx, converted_to_model_json, cdm_corpus2.storage.fetch_root_folder('local'))
self.assertEqual('EpisodeOfCare/partition-data.csv', manifest_after_convertion.entities[0].data_partitions[0].location)
# TODO: Need to change path in C#
cdm_corpus3 = TestHelper.get_local_corpus(self.tests_subpath, test_name)
read_file = TestHelper.get_input_file_content(self.tests_subpath, test_name, 'model.json')
namespace_folder = cdm_corpus3.storage.fetch_root_folder('local')
location_path3 = 'C:\\\\cdm\\\\testData\\\\Persistence\\\\ModelJson\\\\DataPartition\\\\TestModelJsonDataPartitionLocationConsistency\\\\Input\\\\EpisodeOfCare\\\\partition-data.csv'
model_json_as_string = read_file.replace('\uFEFF', '').replace(location_path3, location.replace('\\', '\\\\'))
manifest_read_from_model_json = await ManifestPersistence.from_object(cdm_corpus3.ctx, Model().decode(model_json_as_string), namespace_folder)
self.assertEqual('EpisodeOfCare/partition-data.csv', manifest_read_from_model_json.entities[0].data_partitions[0].location)
def hostname(self, value: str):
if StringUtils.is_null_or_white_space(value):
raise ValueError('Hostname cannot be null or whitespace.')
self._hostname = value
self._formatted_hostname = self._format_hostname(self.hostname)
self._formatted_hostname_no_protocol = self._format_hostname(self._remove_protocol_from_hostname(self._hostname))
async def to_data(document_object_or_path: Union[CdmDocumentDefinition,
str],
manifest: 'CdmManifestDefinition',
res_opt: 'ResolveOptions', options: 'CopyOptions',
ctx: 'CdmCorpusContext') -> Optional['LocalEntity']:
if isinstance(document_object_or_path, str):
# Fetch the document from entity schema.
cdm_entity = await ctx.corpus.fetch_object_async(
document_object_or_path, manifest)
if not isinstance(cdm_entity, CdmEntityDefinition):
logger.error(ctx, DocumentPersistence.__name__,
DocumentPersistence.to_data.__name__,
manifest.at_corpus_path,
CdmLogCode.ERR_INVALID_CAST,
document_object_or_path, 'CdmEntityDefinition')
return None
if not cdm_entity:
logger.error(ctx, DocumentPersistence.__name__,
DocumentPersistence.to_data.__name__,
manifest.at_corpus_path,
CdmLogCode.ERR_PERSIST_CDM_ENTITY_FETCH_ERROR)
return None
entity = await EntityPersistence.to_data(cdm_entity, res_opt,
options, ctx)
if cdm_entity.owner and cdm_entity.owner.object_type == CdmObjectType.DOCUMENT_DEF:
document = cdm_entity.owner # type: CdmDocumentDefinition
entity.imports = []
for element in document.imports:
imp = CdmImportPersistence.to_data(element, res_opt,
options)
# the corpus path in the imports are relative to the document where it was defined.
# when saving in model.json the documents are flattened to the manifest level
# so it is necessary to recalculate the path to be relative to the manifest.
absolute_path = ctx.corpus.storage.create_absolute_corpus_path(
imp.corpusPath, document)
if not StringUtils.is_blank_by_cdm_standard(
document._namespace) and absolute_path.startswith(
document._namespace + ':'):
absolute_path = absolute_path[len(document._namespace
) + 1:]
imp.corpusPath = ctx.corpus.storage.create_relative_corpus_path(
absolute_path, manifest)
entity.imports.append(imp)
else:
logger.warning(ctx, _TAG, DocumentPersistence.to_data.__name__,
manifest.at_corpus_path,
CdmLogCode.WARN_PERSIST_ENTITY_MISSING,
cdm_entity.get_name())
return entity
else:
# TODO: Do something else when document_object_or_path is an object.
pass
def _construct_attribute_context_tree(
self, proj_ctx: 'ProjectionContext') -> None:
"""
Takes all the stored attribute context parameters, creates attribute contexts from them, and then constructs the tree.
:param proj_ctx: The projection context
"""
# Iterate over all the search_for attribute context parameters
for search_for_attr_ctx_param in self._search_for_to_search_for_attr_ctx_param.values(
):
# Fetch all the found attribute context parameters associated with this search_for
found_attr_ctx_params = self._search_for_attr_ctx_param_to_found_attr_ctx_param[
search_for_attr_ctx_param]
# Iterate over all the found attribute context parameters
for found_attr_ctx_param in found_attr_ctx_params:
# Fetch the action attribute context parameter associated with this found
action_attr_ctx_param = self._found_attr_ctx_param_to_action_attr_ctx_param[
found_attr_ctx_param]
# We should only create the found node when found and action have different names. Else collapse the nodes together.
if not StringUtils.equals_with_case(
found_attr_ctx_param._name,
action_attr_ctx_param._name):
# Create the attribute context for found and set it as the parent of action
found_attr_ctx = CdmAttributeContext._create_child_under(
proj_ctx._projection_directive._res_opt,
found_attr_ctx_param)
action_attr_ctx_param._under = found_attr_ctx
# Create the attribute context for action
action_attr_ctx = CdmAttributeContext._create_child_under(
proj_ctx._projection_directive._res_opt,
action_attr_ctx_param)
# Fetch the resolved attribute that should now point at this action attribute context
res_attr_from_action = self._action_attr_ctx_param_to_res_attr.get(
action_attr_ctx_param, None)
# make sure the lineage of the attribute stays linked up
# there can be either (or both) a lineageOut and a lineageIn.
# out lineage is where this attribute came from
# in lineage should be pointing back at this context as a source
lineage_out = self._action_attr_ctx_param_to_lineage_out.get(
action_attr_ctx_param, None) # type: CdmAttributeContext
if lineage_out:
if action_attr_ctx:
action_attr_ctx._add_lineage(lineage_out)
res_attr_from_action.att_ctx = action_attr_ctx # probably the right context for this resAtt, unless ...
lineage_in = self._action_attr_ctx_param_to_lineage_in.get(
action_attr_ctx_param, None) # type: CdmAttributeContext
if lineage_in:
if action_attr_ctx:
lineage_in._add_lineage(action_attr_ctx)
res_attr_from_action.att_ctx = lineage_in # if there is a lineageIn. it points to us as lineage, so it is best
def get_test_folder_path(test_subpath: str, test_name: str, folder_name: str,
is_language_specific: Optional[bool] = False):
test_name = StringUtils.snake_case_to_pascal_case(test_name)
test_folder_path = os.path.join('..', 'TestData', test_subpath, test_name, folder_name, 'Python') \
if is_language_specific else os.path.join('..', 'TestData', test_subpath, test_name,
folder_name)
if folder_name == ACTUAL_OUTPUT_FOLDER_NAME and not os.path.isdir(test_folder_path):
os.makedirs(test_folder_path, exist_ok=True)
return test_folder_path
def from_data(ctx: CdmCorpusContext, obj: Import) -> CdmImport:
imp = ctx.corpus.make_object(CdmObjectType.IMPORT)
corpus_path = obj.get('corpusPath')
if StringUtils.is_blank_by_cdm_standard(corpus_path):
corpus_path = obj.uri
imp.corpus_path = corpus_path
imp.moniker = obj.get('moniker')
return imp
def to_data(instance: 'CdmE2ERelationship', res_opt: ResolveOptions,
options: CopyOptions) -> E2ERelationship:
relationship = E2ERelationship()
if not StringUtils.is_null_or_white_space(instance.relationship_name):
relationship.name = instance.relationship_name
relationship.fromEntity = instance.from_entity
relationship.fromEntityAttribute = instance.from_entity_attribute
relationship.toEntity = instance.to_entity
relationship.toEntityAttribute = instance.to_entity_attribute
return relationship
def _get_new_attribute_name(self,
attribute_state: 'ProjectionAttributeState',
source_attribute_name: str):
current_attribute_name = attribute_state._current_resolved_attribute._resolved_name
ordinal = str(attribute_state._ordinal
) if attribute_state._ordinal is not None else ''
if not self.rename_format:
logger.error(self.ctx, self._TAG,
self.getNewAttributeName.__name__,
self.at_corpus_path,
CdmLogCode.ERR_PROJ_RENAME_FORMAT_IS_NOT_SET)
return ''
attribute_name = StringUtils._replace(self.rename_format, 'a',
source_attribute_name)
attribute_name = StringUtils._replace(attribute_name, 'o', ordinal)
attribute_name = StringUtils._replace(attribute_name, 'm',
current_attribute_name)
return attribute_name
def from_data(ctx: CdmCorpusContext,
data: E2ERelationship) -> CdmE2ERelationship:
relationship = ctx.corpus.make_object(
CdmObjectType.E2E_RELATIONSHIP_DEF)
if not StringUtils.is_null_or_white_space(data.name):
relationship.relationship_name = data.name
relationship.from_entity = data.fromEntity
relationship.from_entity_attribute = data.fromEntityAttribute
relationship.to_entity = data.toEntity
relationship.to_entity_attribute = data.toEntityAttribute
return relationship
def to_data(instance: 'CdmE2ERelationship', res_opt: ResolveOptions,
options: CopyOptions) -> E2ERelationship:
relationship = E2ERelationship()
if not StringUtils.is_null_or_white_space(instance.name):
relationship.name = instance.name
relationship.fromEntity = instance.from_entity
relationship.fromEntityAttribute = instance.from_entity_attribute
relationship.toEntity = instance.to_entity
relationship.toEntityAttribute = instance.to_entity_attribute
relationship.exhibitsTraits = copy_data_utils._array_copy_data(
res_opt, instance.exhibits_traits, options)
return relationship
def _get_number(self, val: str, default_value: int) -> int:
"""Converts the string cardinality to number"""
if StringUtils.equals_with_ignore_case(val, '*'):
return CardinalitySettings._infinite_maximum
try:
number = int(val)
return number
except ValueError:
logger.error(self._ctx, self._TAG, '_get_number',
self._owner.at_corpus_path,
CdmLogCode.ERR_PROJ_STRING_ERROR, val, default_value)
# defaults to min:max DefaultMinimum:DefaultMaximum in the invalid values
return default_value
def from_data(ctx: 'CdmCorpusContext', data: 'OperationAddAttributeGroup') -> 'CdmOperationAddAttributeGroup':
if not data:
return None
add_attribute_group_op = ctx.corpus.make_object(CdmObjectType.OPERATION_ADD_ATTRIBUTE_GROUP_DEF) # type: CdmOperationAddAttributeGroup
if data.type and not StringUtils.equals_with_ignore_case(data.type, OperationTypeConvertor._operation_type_to_string(CdmOperationType.ADD_ATTRIBUTE_GROUP)):
logger.error(_TAG, ctx, '$type {} is invalid for this operation.'.format(data.type))
else:
add_attribute_group_op.type = CdmOperationType.ADD_ATTRIBUTE_GROUP
add_attribute_group_op.attribute_group_name = data.attributeGroupName
add_attribute_group_op.explanation = data.explanation
return add_attribute_group_op
def _get_number(self, val: str, default_value: int) -> int:
"""Converts the string cardinality to number"""
if StringUtils.equals_with_ignore_case(val, '*'):
return CardinalitySettings._infinite_maximum
try:
number = int(val)
return number
except ValueError:
logger.error(
self._TAG, self._ctx,
'Unable to get number for string \'{}\'. Falling to default value {}.'
.format(val, default_value))
# defaults to min:max DefaultMinimum:DefaultMaximum in the invalid values
return default_value
def _replace_wildcard_characters(format: str, projection_owner_name: str,
current_PAS: '******'):
"""
Replace the wildcard character. {a/A} will be replaced with the current attribute name.
{m/M} will be replaced with the entity attribute name. {o} will be replaced with the index of the attribute after an array expansion
"""
if not format:
return ''
ordinal = str(
current_PAS._ordinal) if current_PAS._ordinal is not None else ''
original_member_attribute_name = current_PAS._current_resolved_attribute.target.name if isinstance(
current_PAS._current_resolved_attribute.target,
CdmAttribute) else '' or ''
resolved_member_attribute_name = current_PAS._current_resolved_attribute._resolved_name
value = StringUtils._replace(format, 'a', projection_owner_name)
value = StringUtils._replace(value, 'o', ordinal)
value = StringUtils._replace(value, 'mo',
original_member_attribute_name)
value = StringUtils._replace(value, 'm',
resolved_member_attribute_name)
return value
def from_data(ctx: CdmCorpusContext,
data: E2ERelationship) -> CdmE2ERelationship:
relationship = ctx.corpus.make_object(
CdmObjectType.E2E_RELATIONSHIP_DEF)
if not StringUtils.is_null_or_white_space(data.name):
relationship.relationship_name = data.name
relationship.from_entity = data.fromEntity
relationship.from_entity_attribute = data.fromEntityAttribute
relationship.to_entity = data.toEntity
relationship.to_entity_attribute = data.toEntityAttribute
utils.add_list_to_cdm_collection(
relationship.exhibits_traits,
utils.create_trait_reference_array(ctx, data.exhibitsTraits))
return relationship
async def create_or_update_syms_entities(syms_manifest_content: 'SymsManifestContent', adapter: 'StorageAdapter'):
failed_updated_tables = {}
failed_updated_relationships = {}
failed_removed_tables = {}
failed_removed_relationships = {}
error_mesg = ''
if syms_manifest_content.intial_sync:
await create_or_update_database(syms_manifest_content.database, adapter)
if syms_manifest_content.removed_entities is not None:
for remove_table in syms_manifest_content.removed_entities:
try:
await remove_table_entity(remove_table, syms_manifest_content.database.name, adapter)
except Exception as e:
failed_removed_tables[remove_table] = str(e)
if len(failed_removed_tables) > 0:
error_mesg += 'Failed removed tables : ' + str(failed_removed_tables)
if syms_manifest_content.removed_relationships is not None:
for remove_relationship in syms_manifest_content.removed_relationships:
try:
await remove_relationship_entity(remove_relationship, syms_manifest_content.database.name, adapter)
except Exception as e:
failed_removed_relationships[remove_relationship] = str(e)
if len(failed_removed_relationships) > 0:
error_mesg += 'Failed removed relationships :' + str(failed_removed_relationships)
if syms_manifest_content.entities is not None:
for table in syms_manifest_content.entities:
try:
await create_or_update_table_entity(table, adapter)
except Exception as e:
failed_updated_tables[table.name] = str(e)
if len(failed_updated_tables) > 0:
error_mesg += 'Failed updated tables : ' + str(failed_updated_tables)
if syms_manifest_content.relationships is not None:
for relationship in syms_manifest_content.relationships:
try:
await create_or_update_relationship_entity(relationship, adapter)
except Exception as e:
failed_updated_relationships[relationship.name] = str(e)
if len(failed_updated_relationships) > 0:
error_mesg += 'Failed updated relationships : ' + str(failed_updated_relationships)
if not StringUtils.is_blank_by_cdm_standard(error_mesg):
raise Exception (error_mesg)
