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 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 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
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
def from_data(ctx: 'CdmCorpusContext', data: 'OperationAlterTraits') -> 'CdmOperationAlterTraits': if not data: return None alter_traits_op = OperationBasePersistence.from_data( ctx, CdmObjectType.OPERATION_ALTER_TRAITS_DEF, data) # type: CdmOperationAlterTraits alter_traits_op.traits_to_add = utils.create_trait_reference_array( ctx, data.traitsToAdd) alter_traits_op.traits_to_remove = utils.create_trait_reference_array( ctx, data.traitsToRemove) alter_traits_op.arguments_contain_wildcards = data.argumentsContainWildcards if isinstance(data.applyTo, str): alter_traits_op.apply_to = [data.applyTo] elif isinstance(data.applyTo, list): alter_traits_op.apply_to = data.applyTo elif data.applyTo is not None: logger.error(ctx, _TAG, OperationAlterTraitsPersistence.from_data.__name__, None, CdmLogCode.ERR_PERSIST_PROJ_UNSUPPORTED_PROP, 'applyTo', 'string or list of strings') return alter_traits_op
def _add(self, pas: '******') -> None: """Add to the collection""" if not pas or not pas._current_resolved_attribute or not pas._current_resolved_attribute.resolved_name: logger.error(self._ctx, ProjectionAttributeStateSet._add.__name__, self._TAG, None, CdmLogCode.ERR_PROJ_INVALID_ATTR_STATE) else: self._states.append(pas)
def maximum(self, val: str) -> None: if not CardinalitySettings._is_maximum_valid(val): logger.error(self._TAG, self._ctx, 'Invalid maximum cardinality {}.'.format(val)) else: self._maximum = val self._maximum_number = self._get_number(self._maximum, self._default_maximum)
def _add(self, pas: '******') -> None: """Add to the collection""" if not pas or not pas._current_resolved_attribute or not pas._current_resolved_attribute.resolved_name: logger.error( self._TAG, self._ctx, 'Invalid ProjectionAttributeState provided for addition to the Set. Add operation failed.', ProjectionAttributeStateSet._add.__name__) else: self._states.append(pas)
def maximum(self, val: str) -> None: if not CardinalitySettings._is_maximum_valid(val): logger.error(self._ctx, self._TAG, 'maximum', self._owner.at_corpus_path, CdmLogCode.ERR_VALDN_INVALID_MAX_CARDINALITY, val) else: self._maximum = val self._maximum_number = self._get_number(self._maximum, self._default_maximum)
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 minimum(self, val: str) -> None: from cdm.objectmodel import CdmTypeAttributeDefinition if not CardinalitySettings._is_minimum_valid(val): logger.error(self._TAG, self._ctx, 'Invalid minimum cardinality {}.'.format(val)) else: self._minimum = val self._minimum_number = self._get_number(self._minimum, self._default_minimum) # In the case of type attributes, a '0' minimum cardinality represents a nullable attribute if self._owner and isinstance(self._owner, CdmTypeAttributeDefinition): self._owner.is_nullable = self._minimum_number == 0
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 minimum(self, val: str) -> None: from cdm.objectmodel import CdmTypeAttributeDefinition if not CardinalitySettings._is_minimum_valid(val): logger.error(self._ctx, self._TAG, 'minimum', self._owner.at_corpus_path, CdmLogCode.ERR_VALDN_INVALID_MIN_CARDINALITY, val) else: self._minimum = val self._minimum_number = self._get_number(self._minimum, self._default_minimum) # In the case of type attributes, a '0' minimum cardinality represents a nullable attribute if self._owner and isinstance(self._owner, CdmTypeAttributeDefinition): self._owner.is_nullable = self._minimum_number == 0
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 from_data(ctx: 'CdmCorpusContext', data: 'OperationRenameAttributes') -> 'CdmOperationRenameAttributes': if not data: return None rename_attributes_op = ctx.corpus.make_object(CdmObjectType.OPERATION_RENAME_ATTRIBUTES_DEF) if data.type and not StringUtils.equals_with_ignore_case(data.type, OperationTypeConvertor._operation_type_to_string(CdmOperationType.RENAME_ATTRIBUTES)): logger.error(_TAG, ctx, '$type {} is invalid for this operation.'.format(data.type)) else: rename_attributes_op.type = CdmOperationType.RENAME_ATTRIBUTES if data.explanation: rename_attributes_op.explanation = data.explanation rename_attributes_op.rename_format = data.renameFormat rename_attributes_op.apply_to = data.applyTo return rename_attributes_op
def from_data( ctx: 'CdmCorpusContext', data: 'OperationRenameAttributes' ) -> 'CdmOperationRenameAttributes': if not data: return None rename_attributes_op = OperationBasePersistence.from_data( ctx, CdmObjectType.OPERATION_RENAME_ATTRIBUTES_DEF, data) # type: CdmOperationRenameAttributes rename_attributes_op.rename_format = data.renameFormat if isinstance(data.applyTo, str): rename_attributes_op.apply_to = [data.applyTo] elif isinstance(data.applyTo, list): rename_attributes_op.apply_to = data.applyTo elif data.applyTo is not None: logger.error( ctx, _TAG, OperationRenameAttributesPersistence.from_data.__name__, None, CdmLogCode.ERR_PERSIST_PROJ_UNSUPPORTED_PROP) return rename_attributes_op
def from_data( ctx: 'CdmCorpusContext', data: 'OperationRenameAttributes' ) -> 'CdmOperationRenameAttributes': if not data: return None rename_attributes_op = OperationBasePersistence.from_data( ctx, CdmObjectType.OPERATION_RENAME_ATTRIBUTES_DEF, data) # type: CdmOperationRenameAttributes rename_attributes_op.rename_format = data.renameFormat if isinstance(data.applyTo, str): rename_attributes_op.apply_to = [data.applyTo] elif isinstance(data.applyTo, list): rename_attributes_op.apply_to = data.applyTo elif data.applyTo is not None: logger.error( _TAG, ctx, 'Unsupported: applyTo property type should be string or List<string>.' ) return rename_attributes_op
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( operation_name, ctx, '$type {} is invalid for this operation.'.format(data.type)) else: operation.type = operation_type operation.condition = data.condition operation.explanation = data.explanation operation.source_input = data.sourceInput return operation
def from_data( ctx: 'CdmCorpusContext', data: Union[str, 'EntityReference', 'Projection']) -> 'CdmProjection': from cdm.persistence.cdmfolder.entity_reference_persistence import EntityReferencePersistence if not data: return None projection = ctx.corpus.make_object(CdmObjectType.PROJECTION_DEF) source = EntityReferencePersistence.from_data(ctx, data.get('source')) if data.explanation: projection.explanation = data.explanation if data.condition: projection.condition = data.condition projection.run_sequentially = data.runSequentially if data.operations is not None: operation_jsons = data.operations for operation_json in operation_jsons: type = operation_json.get('$type') if type == 'addCountAttribute': add_count_attribute_op = OperationAddCountAttributePersistence.from_data( ctx, operation_json) projection.operations.append(add_count_attribute_op) elif type == 'addSupportingAttribute': add_supporting_attribute_op = OperationAddSupportingAttributePersistence.from_data( ctx, operation_json) projection.operations.append(add_supporting_attribute_op) elif type == 'addTypeAttribute': add_type_attribute_op = OperationAddTypeAttributePersistence.from_data( ctx, operation_json) projection.operations.append(add_type_attribute_op) elif type == 'excludeAttributes': exclude_attributes_op = OperationExcludeAttributesPersistence.from_data( ctx, operation_json) projection.operations.append(exclude_attributes_op) elif type == 'arrayExpansion': array_expansion_op = OperationArrayExpansionPersistence.from_data( ctx, operation_json) projection.operations.append(array_expansion_op) elif type == 'combineAttributes': combine_attributes_op = OperationCombineAttributesPersistence.from_data( ctx, operation_json) projection.operations.append(combine_attributes_op) elif type == 'renameAttributes': rename_attributes_op = OperationRenameAttributesPersistence.from_data( ctx, operation_json) projection.operations.append(rename_attributes_op) elif type == 'replaceAsForeignKey': replace_as_foreign_key_op = OperationReplaceAsForeignKeyPersistence.from_data( ctx, operation_json) projection.operations.append(replace_as_foreign_key_op) elif type == 'includeAttributes': include_attributes_op = OperationIncludeAttributesPersistence.from_data( ctx, operation_json) projection.operations.append(include_attributes_op) elif type == 'addAttributeGroup': add_attribute_group_op = OperationAddAttributeGroupPersistence.from_data( ctx, operation_json) projection.operations.append(add_attribute_group_op) else: logger.error(_TAG, ctx, 'Invalid operation type \'{}\'.'.format(type), ProjectionPersistence.from_data.__name__) projection.source = source return projection