async def to_data(instance: 'CdmDataPartitionDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> Optional['Partition']:
result = Partition()
result.name = instance.name
result.description = instance.description
result.location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(
instance.ctx.corpus.storage.create_absolute_corpus_path(
instance.location, instance.in_document))
result.refreshTime = instance.refresh_time
result.lastFileModifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
if not result.location:
logger.warning(
DataPartitionPersistence.__name__, instance.ctx,
'Couldn\'t find data partition\'s location for partition {}.'.
format(result.name), DataPartitionPersistence.to_data.__name__)
# filter description since it is mapped to a property
exhibits_traits = filter(
lambda t: t.named_reference != 'is.localized.describedAs',
instance.exhibits_traits)
await utils.process_annotations_to_data(instance.ctx, result,
exhibits_traits)
t2pm = TraitToPropertyMap(instance)
is_hidden_trait = t2pm._fetch_trait_reference('is.hidden')
result.isHidden = bool(is_hidden_trait) or None
csv_trait = t2pm._fetch_trait_reference('is.partition.format.CSV')
if csv_trait:
csv_format_settings = utils.create_csv_format_settings(csv_trait)
if csv_format_settings:
result.fileFormatSettings = csv_format_settings
result.fileFormatSettings.type = 'CsvFormatSettings'
else:
logger.error(
DataPartitionPersistence.__name__, instance.ctx,
'There was a problem while processing csv format trait inside data partition.'
)
return
return result
def to_data(instance: CdmTypeAttributeDefinition, ctx: CdmCorpusContext, res_opt: ResolveOptions, options: CopyOptions) -> TypeAttribute:
properties = TypeAttributePersistence.create_properties(instance, res_opt, options)
origin_data_type_name = TypeInfo(
type_name = '',
properties = properties,
is_complex_type = False,
is_nullable = instance._get_property('isNullable'),
type_family = 'cdm')
t2pm = TraitToPropertyMap(instance)
numeric_traits = t2pm._fetch_trait_reference('is.data_format.numeric.shaped')
if numeric_traits is not None:
for numeric_traits_arg in numeric_traits.argument:
if numeric_traits_arg.name == 'precision':
origin_data_type_name.precision = numeric_traits_arg.value
if numeric_traits_arg.Name == 'scale':
origin_data_type_name.scale = numeric_traits_arg.value
data_format = instance._get_property('dataFormat')
origin_data_type_name = utils.cdm_data_format_to_syms_data_type(data_format, origin_data_type_name)
if origin_data_type_name == None:
return None
if origin_data_type_name.type_name == None:
logger.error(ctx, _TAG, 'toData', instance.at_corpus_path, CdmLogCode.ERR_PERSIST_SYMS_UNKNOWN_DATA_FORMAT,
instance.display_name)
return None
data_col = DataColumn(
origin_data_type_name = origin_data_type_name,
name = instance.name)
return data_col
async def to_data(instance: 'CdmTypeAttributeDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> 'Attribute':
applied_traits = \
[trait for trait in instance.applied_traits if not trait.is_from_property] \
if instance.applied_traits else None
result = Attribute()
result.name = instance.name
description = instance._fetch_property('description')
if description:
result.description = description
result.dataType = TypeAttributePersistence._data_type_to_data(
instance.data_format)
result.traits = copy_data_utils._array_copy_data(
res_opt, applied_traits, options)
await utils.process_annotations_to_data(instance.ctx, result,
instance.applied_traits)
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(
t2pm._fetch_trait_reference('is.hidden')) or None
return result
def create_table_propertybags(instance: CdmLocalEntityDeclarationDefinition, res_opt: ResolveOptions, options: CopyOptions, properties):
if properties == None:
properties = {}
if instance.entity_path is not None:
path_tuple = StorageUtils.split_namespace_path(instance.entity_path)
if path_tuple == None:
logger.error(instance.ctx, _TAG, LocalEntityDeclarationPersistence.create_table_propertybags.__name__, instance.at_corpus_path, CdmLogCode.ERR_PERSIST_SYMS_ENTITY_PATH_NULL, instance.entity_name)
return None
properties['cdm:entityPath'] = path_tuple[1]
t2pm = TraitToPropertyMap(instance)
is_hidden_trait = t2pm._fetch_trait_reference('is.hidden')
if not 'cdm:description' in properties:
properties['cdm:description'] = instance.explanation
if instance.last_child_file_modified_time is not None:
properties['cdm:lastChildFileModifiedTime'] = instance.last_child_file_modified_time
if instance.last_file_modified_time is not None:
properties['cdm:lastFileModifiedTime'] = instance.last_file_modified_time
if instance.last_file_status_check_time is not None:
properties['cdm:lastFileStatusCheckTime'] = instance.last_file_status_check_time
if is_hidden_trait is not None:
properties['cdm:isHidden'] = True
if instance.exhibits_traits is not None and len(instance.exhibits_traits) > 0:
properties['cdm:entityDecTraits'] = copy_data_utils._array_copy_data(res_opt, instance.exhibits_traits, options)
return properties
async def to_data(instance: 'CdmDataPartitionDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions') -> Optional['Partition']:
result = Partition()
result.name = instance.name
result.description = instance.description
result.location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(
instance.ctx.corpus.storage.create_absolute_corpus_path(instance.location, instance.in_document))
result.refreshTime = instance.refresh_time
result.lastFileModifiedTime = utils.get_formatted_date_string(instance.last_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(instance.last_file_status_check_time)
if result.name is None:
logger.warning(instance.ctx, _TAG, DataPartitionPersistence.to_data.__name__, instance.at_corpus_path,
CdmLogCode.WARN_PERSIST_PARTITION_NAME_NULL)
result.name = ''
if not result.location:
logger.warning(instance.ctx, _TAG, DataPartitionPersistence.to_data.__name__, instance.at_corpus_path,
CdmLogCode.WARN_PERSIST_PARTITION_LOC_MISSING, result.Name)
# filter description since it is mapped to a property
exhibits_traits = filter(lambda t: t.named_reference != 'is.localized.describedAs', instance.exhibits_traits)
await utils.process_traits_and_annotations_to_data(instance.ctx, result, exhibits_traits)
t2pm = TraitToPropertyMap(instance)
is_hidden_trait = t2pm._fetch_trait_reference('is.hidden')
result.isHidden = bool(is_hidden_trait) or None
csv_trait = t2pm._fetch_trait_reference('is.partition.format.CSV')
if csv_trait:
csv_format_settings = utils.create_csv_format_settings(csv_trait)
if csv_format_settings:
result.fileFormatSettings = csv_format_settings
result.fileFormatSettings.type = 'CsvFormatSettings'
else:
logger.error(instance.ctx, _TAG, DataPartitionPersistence.to_data.__name__, instance.at_corpus_path,
CdmLogCode.ERR_PERSIST_CSV_PROCESSING_ERROR)
return
return result
def create_data_source(instance: CdmManifestDefinition) -> DataSource:
source = DataSource(None)
t2pm = TraitToPropertyMap(instance)
source_traits = t2pm._fetch_trait_reference(ManifestPersistence.db_location_trait)
if source_traits is not None and source_traits.arguments is not None and len(source_traits.arguments) == 1 and \
source_traits.arguments[0].name == ManifestPersistence.db_location_trait_arg_name:
source.location = utils.corpus_path_to_syms_path(source_traits.arguments[0].value, instance.ctx.corpus.storage)
if source.location == None:
logger.error(instance.ctx, _TAG, 'create_data_source', instance.at_corpus_path, CdmLogCode.ERR_PERSIST_SYMS_STORAGE_SOURCE_TRAIT_ERROR, ManifestPersistence.db_location_trait , ManifestPersistence.db_location_trait_arg_name)
return None
return source
async def to_data(instance: 'CdmReferencedEntityDeclarationDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> Optional['ReferenceEntity']:
source_index = instance.entity_path.rfind('/')
if source_index == -1:
logger.error(
instance.ctx, _TAG, 'to_data', instance.at_corpus_path,
CdmLogCode.
ERR_PERSIST_MODELJSON_ENTITY_PARTITION_CONVERSION_ERROR,
instance.at_corpus_path)
return None
reference_entity = ReferenceEntity()
t2pm = TraitToPropertyMap(instance)
reference_entity.type = 'ReferenceEntity'
reference_entity.name = instance.entity_name
reference_entity.source = instance.entity_path[source_index + 1:]
reference_entity.description = instance.explanation
reference_entity.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
reference_entity.lastFileModifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
reference_entity.isHidden = bool(
t2pm._fetch_trait_reference('is.hidden')) or None
properties_trait = t2pm._fetch_trait_reference(
'is.propertyContent.multiTrait')
if properties_trait:
reference_entity.modelId = properties_trait.arguments[0].value
utils.process_traits_and_annotations_to_data(instance.ctx,
reference_entity,
instance.exhibits_traits)
return reference_entity
async def to_data(instance: 'CdmTypeAttributeDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions') -> 'Attribute':
result = Attribute()
result.name = instance.name
description = instance._get_property('description')
if description:
result.description = description
result.dataType = TypeAttributePersistence._data_type_to_data(instance.data_format)
utils.process_traits_and_annotations_to_data(instance.ctx, result, instance.applied_traits)
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(t2pm._fetch_trait_reference('is.hidden')) or None
return result
async def to_data(instance: 'CdmLocalEntityDeclarationDefinition',
manifest: 'CdmManifestDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> 'LocalEntity':
# Fetch the document from entity schema.
entity = await DocumentPersistence.to_data(instance.entity_path,
manifest, res_opt, options,
instance.ctx)
if not entity:
return None
if not entity.description:
entity.description = instance.explanation
entity.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
entity.lastFileModifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
entity.lastChildFileModifiedTime = utils.get_formatted_date_string(
instance.last_child_file_modified_time)
t2pm = TraitToPropertyMap(instance)
# Find the trait containing the schema info.
schemas = t2pm._fetch_property_value('cdmSchemas')
if schemas:
entity.schemas = schemas
entity.isHidden = bool(
t2pm._fetch_trait_reference('is.hidden')) or None
if instance.data_partitions:
entity.partitions = []
for partition in instance.data_partitions:
partiton = await DataPartitionPersistence.to_data(
partition, res_opt, options)
if partition:
entity.partitions.append(partiton)
else:
logger.error(
ctx, _TAG, "to_data", instance.at_corpus_path,
CdmLogCode.
ERR_PERSIST_MODELJSON_ENTITY_PARTITION_CONVERSION_ERROR
)
return None
return entity
def to_data(instance: 'CdmDataPartitionDefinition',
obj: 'StorageDescriptor', res_opt: 'ResolveOptions',
options: 'CopyOptions') -> 'StorageDescriptor':
obj.properties = {}
if instance.name is not None:
obj.properties['cdm:name'] = instance.name
if instance.last_file_status_check_time is not None:
obj.properties[
'cdm:lastFileStatusCheckTime'] = time_utils._get_formatted_date_string(
instance.last_file_status_check_time)
if instance.last_file_modified_time is not None:
obj.properties[
'cdm:lastFileModifiedTime'] = time_utils._get_formatted_date_string(
instance.last_file_modified_time)
if instance.exhibits_traits is not None:
tpm = TraitToPropertyMap(instance)
csv_trait = tpm._fetch_trait_reference('is.partition.format.CSV')
if csv_trait is not None:
instance.exhibits_traits.remove('is.partition.format.CSV')
if len(instance.exhibits_traits) > 0:
obj.properties[
'cdm:traits'] = copy_data_utils._array_copy_data(
res_opt, instance.exhibits_traits, options)
if csv_trait is not None:
instance.exhibits_traits.append(csv_trait)
properties = DataPartitionPersistence.fill_property_bag_from_csv_trait(
instance)
if properties is not None:
obj.format = FormatInfo(
input_format=InputFormat.
orgapachehadoopmapred_sequence_file_input_format,
output_format=OutputFormat.
orgapachehadoophiveqlio_hive_sequence_file_output_format,
serialize_lib=SerializeLib.
orgapachehadoophiveserde2lazy_lazy_simple_ser_de,
format_type=FormatType.csv,
properties=properties)
else:
#error
return None
return obj
def fill_property_bag_from_csv_trait(
instance: 'CdmDataPartitionDefinition', properties=None):
tpm = TraitToPropertyMap(instance)
csv_trait = tpm._fetch_trait_reference('is.partition.format.CSV')
if csv_trait is not None:
if properties == None:
properties = {}
for csv_trait_arg in csv_trait.arguments:
key = None
# map to syms define properties
if csv_trait_arg.name == 'columnHeaders':
key = 'header'
elif csv_trait_arg.name == 'delimiter':
key = 'field.delim'
else:
key = csv_trait_arg.value
properties[key] = csv_trait_arg.value
return properties
async def to_data(instance: 'CdmManifestDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> Optional['Model']:
result = Model()
# process_traits_and_annotations_to_data also processes extensions.
await utils.process_traits_and_annotations_to_data(
instance.ctx, result, instance.exhibits_traits)
result.name = instance.manifest_name
result.description = instance.explanation
result.modifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
result.lastChildFileModifiedTime = utils.get_formatted_date_string(
instance.last_child_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
result.documentVersion = instance.document_version
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(
t2pm._fetch_trait_reference('is.hidden')) or None
application_trait = t2pm._fetch_trait_reference('is.managedBy')
if application_trait:
result.application = application_trait.arguments[0].value
version_trait = t2pm._fetch_trait_reference(
'is.modelConversion.modelVersion')
if version_trait:
result.version = version_trait.arguments[0].value
else:
result.version = '1.0'
culture_trait = t2pm._fetch_trait_reference('is.partition.culture')
if culture_trait:
result.culture = culture_trait.arguments[0].value
reference_entity_locations = {}
reference_models = OrderedDict()
reference_models_trait = t2pm._fetch_trait_reference(
'is.modelConversion.referenceModelMap')
if reference_models_trait:
ref_models = reference_models_trait.arguments[0].value
for element in ref_models:
reference_models[element.id] = element.location
reference_entity_locations[element.location] = element.id
if instance.entities:
result.entities = []
# Schedule processing of each entity to be added to the manifest
for entity in instance.entities:
element = None
if entity.object_type == CdmObjectType.LOCAL_ENTITY_DECLARATION_DEF:
element = await LocalEntityDeclarationPersistence.to_data(
entity, instance, res_opt, options)
elif entity.object_type == CdmObjectType.REFERENCED_ENTITY_DECLARATION_DEF:
element = await ReferencedEntityDeclarationPersistence.to_data(
entity, res_opt, options)
location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(
entity.entity_path)
if StringUtils.is_blank_by_cdm_standard(location):
logger.error(
instance.ctx, _TAG, 'to_data',
instance.at_corpus_path, CdmLogCode.
ERR_PERSIST_MODELJSON_INVALID_ENTITY_PATH,
entity.entity_name)
element = None
reference_entity = element # type: ReferenceEntity
if reference_entity:
# path separator can differ depending on the adapter, cover the case where path uses '/' or '\'
last_slash_location = location.rfind(
'/') if location.rfind('/') > location.rfind(
'\\') else location.rfind('\\')
if last_slash_location > 0:
location = location[:last_slash_location]
if reference_entity.modelId:
saved_location = reference_models.get(
reference_entity.modelId)
if saved_location is not None and saved_location != location:
logger.error(
instance.ctx, 'to_data',
instance.at_corpus_path, _TAG, CdmLogCode.
ERR_PERSIST_MODELJSON_MODEL_ID_DUPLICATION)
element = None
elif saved_location is None:
reference_models[
reference_entity.modelId] = location
reference_entity_locations[
location] = reference_entity.modelId
elif not reference_entity.modelId and location in reference_entity_locations:
reference_entity.modelId = reference_entity_locations[
location]
else:
reference_entity.modelId = str(uuid.uuid4())
reference_models[
reference_entity.modelId] = location
reference_entity_locations[
location] = reference_entity.modelId
if element:
result.entities.append(element)
else:
logger.error(
instance.ctx, _TAG, 'to_data', instance.at_corpus_path,
CdmLogCode.
ERR_PERSIST_MODELJSON_ENTITY_DECLARATION_CONVERSION_ERROR,
entity.entity_name)
if reference_models:
result.referenceModels = []
for value, key in reference_models.items():
model = ReferenceModel()
model.id = value
model.location = key
result.referenceModels.append(model)
if instance.relationships is not None and len(
instance.relationships) > 0:
result.relationships = [] # type: List[SingleKeyRelationship]
for cdm_relationship in instance.relationships:
relationship = await RelationshipPersistence.to_data(
cdm_relationship, res_opt, options, instance.ctx)
if relationship is not None:
result.relationships.append(relationship)
result.imports = []
if instance.imports:
for element in instance.imports:
import_obj = ImportPersistence.to_data(element, res_opt,
options)
if import_obj:
result.imports.append(import_obj)
# Importing foundations.cdm.json to resolve trait properly on manifest
if instance.imports is None or instance.imports.item(
Constants._FOUNDATIONS_CORPUS_PATH,
check_moniker=False) is None:
foundations_import = Import()
foundations_import.corpusPath = Constants._FOUNDATIONS_CORPUS_PATH
result.imports.append(foundations_import)
return result
async def to_data(instance: 'CdmManifestDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions') -> Optional['Model']:
result = Model()
# process_traits_and_annotations_to_data also processes extensions.
utils.process_traits_and_annotations_to_data(instance.ctx, result, instance.exhibits_traits)
result.name = instance.manifest_name
result.description = instance.explanation
result.modifiedTime = utils.get_formatted_date_string(instance.last_file_modified_time)
result.lastChildFileModifiedTime = utils.get_formatted_date_string(instance.last_child_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(instance.last_file_status_check_time)
result.documentVersion = instance.document_version
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(t2pm._fetch_trait_reference('is.hidden')) or None
application_trait = t2pm._fetch_trait_reference('is.managedBy')
if application_trait:
result.application = application_trait.arguments[0].value
version_trait = t2pm._fetch_trait_reference('is.modelConversion.modelVersion')
if version_trait:
result.version = version_trait.arguments[0].value
else:
result.version = '1.0'
culture_trait = t2pm._fetch_trait_reference('is.partition.culture')
if culture_trait:
result.culture = culture_trait.arguments[0].value
reference_entity_locations = {}
reference_models = OrderedDict()
reference_models_trait = t2pm._fetch_trait_reference('is.modelConversion.referenceModelMap')
if reference_models_trait:
ref_models = reference_models_trait.arguments[0].value
for element in ref_models:
reference_models[element.id] = element.location
reference_entity_locations[element.location] = element.id
if instance.entities:
result.entities = []
# Schedule processing of each entity to be added to the manifest
for entity in instance.entities:
element = None
if entity.object_type == CdmObjectType.LOCAL_ENTITY_DECLARATION_DEF:
element = await LocalEntityDeclarationPersistence.to_data(entity, instance, res_opt, options)
elif entity.object_type == CdmObjectType.REFERENCED_ENTITY_DECLARATION_DEF:
element = await ReferencedEntityDeclarationPersistence.to_data(entity, res_opt, options)
location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(entity.entity_path)
if not location:
logger.error(_TAG, instance.ctx, 'Invalid entity path set in entity {}'.format(entity.entity_name))
element = None
reference_entity = element # type: ReferenceEntity
if reference_entity:
location = location[:location.rfind('/')]
if reference_entity.modelId:
saved_location = reference_models.get(reference_entity.modelId)
if saved_location is not None and saved_location != location:
logger.error(_TAG, instance.ctx, 'Same ModelId pointing to different locations')
element = None
elif saved_location is None:
reference_models[reference_entity.modelId] = location
reference_entity_locations[location] = reference_entity.modelId
elif not reference_entity.modelId and location in reference_entity_locations:
reference_entity.modelId = reference_entity_locations[location]
else:
reference_entity.modelId = str(uuid.uuid4())
reference_models[reference_entity.modelId] = location
reference_entity_locations[location] = reference_entity.modelId
if element:
result.entities.append(element)
else:
logger.error(_TAG, instance.ctx,
'There was an error while trying to convert {}\'s entity declaration to model json format.'.format(entity.entity_name))
if reference_models:
result.referenceModels = []
for value, key in reference_models.items():
model = ReferenceModel()
model.id = value
model.location = key
result.referenceModels.append(model)
if instance.relationships is not None and len(instance.relationships) > 0:
result.relationships = [] # type: List[SingleKeyRelationship]
for cdm_relationship in instance.relationships:
relationship = await RelationshipPersistence.to_data(cdm_relationship, res_opt, options, instance.ctx)
if relationship is not None:
result.relationships.append(relationship)
else:
logger.error(_TAG, instance.ctx, 'There was an error while trying to convert cdm relationship to model.json relationship.')
return None
if instance.imports:
result.imports = []
for element in instance.imports:
import_obj = ImportPersistence.to_data(element, res_opt, options)
if import_obj:
result.imports.append(import_obj)
return result
def from_object(ctx: CdmCorpusContext, docname: str, namespace: str, path: str,
data_obj: 'SymsManifestContent') -> 'CdmManifestDefinition':
database = data_obj.database
if database == None or database.type != SASEntityType.database:
logger.error(ctx, _TAG, 'from_object', None, CdmLogCode.ERR_PERSIST_SYMS_INVALID_DB_OBJECT)
return None
database_properties = DatabaseProperties.deserialize(database.properties)
source = DataSource(None).deserialize(database_properties.source)
if database_properties == None or source == None:
logger.error(ctx, _TAG, 'from_object', None, CdmLogCode.ERR_PERSIST_SYMS_INVALID_DB_PROP_OBJECT)
return None
properties = database_properties.properties
manifest = ctx.corpus.make_object(CdmObjectType.MANIFEST_DEF)
manifest._folder_path = path
manifest._namespace = namespace
manifest.manifest_name = data_obj.database.name
manifest.name = docname
manifest.explanation = database_properties.description
if properties is not None:
if "cdm:schema" in properties:
manifest.schema = properties["cdm:schema"]
if "cdm:jsonSchemaSemanticVersion" in properties:
manifest.json_schema_semantic_version = properties["cdm:jsonSchemaSemanticVersion"]
if "cdm:documentVersion" in properties:
manifest.DocumentVersion = properties["cdm:documentVersion"]
if "cdm:traits" in properties:
utils.add_list_to_cdm_collection(manifest.exhibits_traits,
utils.create_trait_reference_array(ctx, properties["cdm:traits"]))
if "cdm:imports" in properties:
for import_obj in properties["cdm:imports"]:
manifest.imports.append(ImportPersistence.from_data(ctx, json.loads(import_obj)))
if "cdm:lastFileStatusCheckTime" in properties:
manifest.last_file_status_check_time = dateutil.parser.parse(properties["cdm:lastFileStatusCheckTime"])
if "cdm:lastFileModifiedTime" in properties:
manifest.last_file_modified_time = dateutil.parser.parse(properties["cdm:lastFileModifiedTime"])
if "cdm:lastChildFileModifiedTime" in properties:
manifest.last_child_file_modified_time = dateutil.parser.parse(properties["cdm:lastChildFileModifiedTime"])
t2pm = TraitToPropertyMap(manifest)
source_trait = t2pm._fetch_trait_reference(ManifestPersistence.db_location_trait)
if source_trait == None:
source_trait = utils.create_source_trait(ctx, ManifestPersistence.db_location_trait, ManifestPersistence.db_location_trait_arg_name)
manifest.exhibits_traits.append(source_trait)
adls_path = utils.syms_path_to_adls_adapter_path(source.location)
adls_corpus_path = ctx.corpus.storage.adapter_path_to_corpus_path(adls_path)
if not adls_corpus_path:
path_tuple = StorageUtils.split_namespace_path(source_trait.arguments[0].value)
obj = utils.create_and_mount_adls_adapter_from_adls_path(ctx.corpus.storage, adls_path, path_tuple[0])
if obj == None:
logger.error(ctx, _TAG, 'from_object', None, CdmLogCode.ERR_PERSIST_SYMS_ADLS_ADAPTER_NOT_MOUNTED, adls_path)
return None
if data_obj.entities is not None:
for item in data_obj.entities.items:
entity_obj = TableEntity(None, None).deserialize(item)
if entity_obj.type == SASEntityType.table:
entity = LocalEntityDeclarationPersistence.from_data(ctx, entity_obj, manifest, database_properties.source.location)
if entity is not None:
manifest.entities.append(entity)
else:
logger.warning(ctx, _TAG, 'from_object', None, CdmLogCode.WARN_PERSIST_SYMS_ENTITY_SKIPPED, entity_obj.name)
if not (x for x in manifest.imports if x.corpus_path == Constants._FOUNDATIONS_CORPUS_PATH) or len(manifest.imports) == 0:
manifest.imports.append(Constants._FOUNDATIONS_CORPUS_PATH)
if data_obj.relationships is not None:
for item in data_obj.relationships.items:
relationship_entity = RelationshipEntity(None, None).deserialize(item)
manifest.relationships.extend(E2ERelationshipPersistence.from_data(ctx, relationship_entity))
# TODO: Submanifest
return manifest
