Exemplo n.º 1
0
    def to_data(instance: CdmManifestDefinition, res_opt: ResolveOptions,
                options: CopyOptions) -> ManifestContent:
        manifest = ManifestContent()

        manifest.manifestName = instance.manifest_name
        manifest.schema = instance.schema
        manifest.jsonSchemaSemanticVersion = instance.json_schema_semantic_version
        manifest.lastFileStatusCheckTime = time_utils.get_formatted_date_string(
            instance.last_file_status_check_time)
        manifest.lastFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_file_modified_time)
        manifest.lastChildFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_child_file_modified_time)
        manifest.explanation = instance.explanation
        manifest.exhibitsTraits = utils.array_copy_data(
            res_opt, instance.exhibits_traits, options)
        manifest.entities = utils.array_copy_data(res_opt, instance.entities,
                                                  options)
        manifest.subManifests = utils.array_copy_data(res_opt,
                                                      instance.sub_manifests,
                                                      options)
        manifest.imports = [
            ImportPersistence.to_data(importDoc, res_opt, options)
            for importDoc in instance.imports
        ]
        manifest.relationships = [
            E2ERelationshipPersistence.to_data(relationship, res_opt, options)
            for relationship in instance.relationships
        ]

        return manifest
    def to_data(instance: CdmManifestDeclarationDefinition,
                res_opt: ResolveOptions,
                options: CopyOptions) -> ManifestDeclaration:
        data = ManifestDeclaration()

        data.manifestName = instance.manifest_name
        data.definition = instance.definition
        data.explanation = instance.explanation
        data.lastFileStatusCheckTime = time_utils.get_formatted_date_string(
            instance.last_file_status_check_time)
        data.lastFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_file_modified_time)

        return data
    def to_data(instance: CdmDataPartitionPatternDefinition, res_opt: ResolveOptions, options: CopyOptions) -> DataPartitionPattern:
        data = DataPartitionPattern()

        data.name = instance.name
        data.lastFileStatusCheckTime = time_utils.get_formatted_date_string(instance.last_file_status_check_time)
        data.lastFileModifiedTime = time_utils.get_formatted_date_string(instance.last_file_modified_time)
        data.explanation = instance.explanation
        data.rootLocation = instance.root_location
        data.regularExpression = instance.regular_expression
        data.parameters = instance.parameters
        data.specializedSchema = instance.specialized_schema
        data.exhibitsTraits = utils.array_copy_data(res_opt, instance.exhibits_traits, options)

        return data
Exemplo n.º 4
0
 def test_load_folder_with_no_entity_folders(self):
     """Testing for manifest impl instance with no entities and no sub manifests."""
     test_name = 'test_load_folder_with_no_entity_folders'
     corpus = self.get_corpus()
     content = TestHelper.get_input_file_content(self.tests_subpath,
                                                 test_name,
                                                 'empty.manifest.cdm.json')
     cdm_manifest = ManifestPersistence.from_object(
         corpus.ctx, 'cdmTest', 'someNamespace', '/',
         ManifestContent().decode(content))
     self.assertEqual(cdm_manifest.schema, 'CdmManifestDefinition.cdm.json')
     self.assertEqual(cdm_manifest.manifest_name, 'cdmTest')
     self.assertEqual(cdm_manifest.json_schema_semantic_version, '0.9.0')
     self.assertEqual(
         time_utils.get_formatted_date_string(
             cdm_manifest.last_file_modified_time),
         '2008-09-15T23:53:23.000Z')
     self.assertEqual(cdm_manifest.explanation,
                      'test cdm folder for cdm version 0.9+')
     self.assertEqual(1, len(cdm_manifest.imports))
     self.assertEqual(cdm_manifest.imports[0].corpus_path,
                      '/primitives.cdm.json')
     self.assertEqual(0, len(cdm_manifest.entities))
     self.assertEqual(1, len(cdm_manifest.exhibits_traits))
     self.assertEqual(0, len(cdm_manifest.sub_manifests))
    def to_data(instance: CdmReferencedEntityDeclarationDefinition,
                res_opt: ResolveOptions,
                options: CopyOptions) -> ReferencedEntityDeclaration:
        data = ReferencedEntityDeclaration()

        data.entityName = instance.entity_name
        data.explanation = instance.explanation
        data.lastFileStatusCheckTime = time_utils.get_formatted_date_string(
            instance.last_file_status_check_time)
        data.lastFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_file_modified_time)
        data.entityPath = instance.entity_path
        data.exhibitsTraits = utils.array_copy_data(res_opt,
                                                    instance.exhibits_traits,
                                                    options)

        return data
Exemplo n.º 6
0
    async def test_loads_and_sets_times_correctly(self):
        """Test modified times for manifest and files beneath it"""

        input_path = TestHelper.get_input_folder_path(
            self.tests_subpath, 'test_loads_and_sets_times_correctly')
        time_before_load = datetime.now(timezone.utc)

        cdm_corpus = self.get_corpus()
        cdm_corpus.storage.mount('someNamespace', LocalAdapter(input_path))
        cdm_corpus.storage.mount('local', LocalAdapter(input_path))
        cdm_corpus.storage.unmount('cdm')
        cdm_corpus.storage.default_namespace = 'local'
        cdm_manifest = await cdm_corpus.fetch_object_async(
            'someNamespace:/default.manifest.cdm.json')
        status_time_at_load = cdm_manifest.last_file_status_check_time
        # hard coded because the time comes from inside the file
        self.assertEqual(
            time_utils.get_formatted_date_string(status_time_at_load),
            '2019-02-01T15:36:19.410Z')

        time.sleep(1)

        await cdm_manifest.file_status_check_async()

        self.assertGreater(cdm_manifest.last_file_status_check_time,
                           time_before_load)
        self.assertGreater(cdm_manifest.last_file_status_check_time,
                           status_time_at_load)
        self.assertEqual(1, len(cdm_manifest.sub_manifests))
        self.assertGreater(
            cdm_manifest.sub_manifests[0].last_file_status_check_time,
            time_before_load)
        self.assertEqual(1, len(cdm_manifest.entities))
        self.assertEqual(1, len(cdm_manifest.entities[0].data_partitions))

        entity = cdm_manifest.entities[0]
        sub_manifest = cdm_manifest.sub_manifests[0]
        max_time = time_utils.max_time(entity.last_file_modified_time,
                                       sub_manifest.last_file_modified_time)
        self.assertEqual(
            time_utils.get_formatted_date_string(
                cdm_manifest.last_child_file_modified_time),
            time_utils.get_formatted_date_string(max_time))
Exemplo n.º 7
0
    def to_data(instance: CdmLocalEntityDeclarationDefinition,
                res_opt: 'ResolveOptions', options: 'CopyOptions'):
        local_entity = LocalEntityDeclaration()

        local_entity.entityName = instance.entity_name
        local_entity.explanation = instance.explanation
        local_entity.entityPath = instance.entity_path
        local_entity.lastFileStatusCheckTime = time_utils.get_formatted_date_string(
            instance.last_file_status_check_time)
        local_entity.lastFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_file_modified_time)
        local_entity.lastChildFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_child_file_modified_time)
        local_entity.exhibitsTraits = utils.array_copy_data(
            res_opt, instance.exhibits_traits, options)
        local_entity.dataPartitions = utils.array_copy_data(
            res_opt, instance.data_partitions, options)
        local_entity.dataPartitionPatterns = utils.array_copy_data(
            res_opt, instance.data_partition_patterns, options)

        return local_entity
    def to_data(instance: 'CdmDataPartitionDefinition',
                res_opt: 'ResolveOptions',
                options: 'CopyOptions') -> 'DataPartition':
        data_partition = DataPartition()

        data_partition.location = instance.location
        data_partition.specializedSchema = instance.specialized_schema
        data_partition.lastFileStatusCheckTime = time_utils.get_formatted_date_string(
            instance.last_file_status_check_time)
        data_partition.lastFileModifiedTime = time_utils.get_formatted_date_string(
            instance.last_file_modified_time)
        data_partition.exhibitsTraits = utils.array_copy_data(
            res_opt, instance.exhibits_traits, options)

        if instance.arguments:
            data_partition.arguments = []
            for argument_list in instance.arguments:
                for argument_value in argument_list['1']:
                    argument = {}
                    argument[argument_list['0']] = argument_value
                    data_partition.arguments.append(argument)

        return data_partition