Python Artifact.import_data方法代码示例

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_load_with_archive_filepath_modified(self):
        # Save an artifact for use in the following test case.
        fp = os.path.join(self.test_dir.name, 'artifact.qza')
        Artifact.import_data(FourInts, [-1, 42, 0, 43]).save(fp)

        # Load the artifact from a filepath then save a different artifact to
        # the same filepath. Assert that both artifacts produce the correct
        # views of their data.
        #
        # `load` used to be lazy, only extracting data when it needed to (e.g.
        # when `save` or `view` was called). This was buggy as the filepath
        # could have been deleted, or worse, modified to contain a different
        # .qza file. Thus, the wrong archive could be extracted on demand, or
        # the archive could be missing altogether. There isn't an easy
        # cross-platform compatible way to solve this problem, so Artifact.load
        # is no longer lazy and always extracts its data immediately. The real
        # motivation for lazy loading was for quick inspection of archives
        # without extracting/copying data, so that API is now provided through
        # Artifact.peek.
        artifact1 = Artifact.load(fp)
        Artifact.import_data(FourInts, [10, 11, 12, 13]).save(fp)
        artifact2 = Artifact.load(fp)

        self.assertEqual(artifact1.view(list), [-1, 42, 0, 43])
        self.assertEqual(artifact2.view(list), [10, 11, 12, 13])

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_with_filepath_multi_file_data_layout(self):
        fp = os.path.join(self.test_dir.name, 'test.txt')
        with open(fp, 'w') as fh:
            fh.write('42\n')

        with self.assertRaisesRegex(ValueError,
                                    "FourIntsDirectoryFormat.*directory"):
            Artifact.import_data(FourInts, fp)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_invalid_type(self):
        with self.assertRaisesRegex(TypeError,
                                    'concrete semantic type.*Visualization'):
            Artifact.import_data(qiime.core.type.Visualization, self.test_dir)

        with self.assertRaisesRegex(TypeError,
                                    'concrete semantic type.*Visualization'):
            Artifact.import_data('Visualization', self.test_dir)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_with_unreachable_path(self):
        with self.assertRaisesRegex(ValueError, "does not exist"):
            Artifact.import_data(IntSequence1,
                                 os.path.join(self.test_dir.name, 'foo.txt'))

        with self.assertRaisesRegex(ValueError, "does not exist"):
            Artifact.import_data(FourInts,
                                 os.path.join(self.test_dir.name, 'bar', ''))

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_with_invalid_format_single_file(self):
        fp = os.path.join(self.test_dir.name, 'foo.txt')
        with open(fp, 'w') as fh:
            fh.write('42\n')
            fh.write('43\n')
            fh.write('abc\n')
            fh.write('123\n')

        error_regex = "foo.txt.*IntSequenceFormat"
        with self.assertRaisesRegex(ValueError, error_regex):
            Artifact.import_data(IntSequence1, fp)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_async(self):
        concatenate_ints = self.plugin.methods['concatenate_ints']
        concatenate_ints_markdown = \
            self.plugin.methods['concatenate_ints_markdown']

        artifact1 = Artifact.import_data(IntSequence1, [0, 42, 43])
        artifact2 = Artifact.import_data(IntSequence2, [99, -22])

        for method in concatenate_ints, concatenate_ints_markdown:
            future = method.async(artifact1, artifact1, artifact2, 55, 1)

            self.assertIsInstance(future, concurrent.futures.Future)
            result = future.result()

            # Test properties of the `Results` object.
            self.assertIsInstance(result, tuple)
            self.assertIsInstance(result, Results)
            self.assertEqual(len(result), 1)
            self.assertEqual(result.concatenated_ints.view(list),
                             [0, 42, 43, 0, 42, 43, 99, -22, 55, 1])

            result = result[0]

            self.assertIsInstance(result, Artifact)
            self.assertEqual(result.type, IntSequence1)

            self.assertIsInstance(result.uuid, uuid.UUID)

            # Can retrieve multiple views of different type.
            exp_list_view = [0, 42, 43, 0, 42, 43, 99, -22, 55, 1]
            self.assertEqual(result.view(list), exp_list_view)
            self.assertEqual(result.view(list), exp_list_view)

            exp_counter_view = collections.Counter(
                {0: 2, 42: 2, 43: 2, 99: 1, -22: 1, 55: 1, 1: 1})
            self.assertEqual(result.view(collections.Counter),
                             exp_counter_view)
            self.assertEqual(result.view(collections.Counter),
                             exp_counter_view)

            # Accepts IntSequence1 | IntSequence2
            artifact3 = Artifact.import_data(IntSequence2, [10, 20])
            future = method.async(artifact3, artifact1, artifact2, 55, 1)
            result, = future.result()

            self.assertEqual(result.type, IntSequence1)
            self.assertEqual(result.view(list),
                             [10, 20, 0, 42, 43, 99, -22, 55, 1])

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_async(self):
        mapping_viz = self.plugin.visualizers['mapping_viz']

        artifact1 = Artifact.import_data(Mapping, {'foo': 'abc', 'bar': 'def'})
        artifact2 = Artifact.import_data(
            Mapping, {'baz': 'abc', 'bazz': 'ghi'})

        future = mapping_viz.async(artifact1, artifact2, 'Key', 'Value')

        self.assertIsInstance(future, concurrent.futures.Future)
        result = future.result()

        # Test properties of the `Results` object.
        self.assertIsInstance(result, tuple)
        self.assertIsInstance(result, Results)
        self.assertEqual(len(result), 1)
        self.assertEqual(result.visualization, result[0])

        result = result[0]

        self.assertIsInstance(result, Visualization)
        self.assertEqual(result.type, qiime.core.type.Visualization)

        self.assertIsInstance(result.uuid, uuid.UUID)

        # TODO qiime.sdk.Visualization doesn't have an API to access its
        # contents yet. For now, save and assert the correct files are present.
        filepath = os.path.join(self.test_dir.name, 'visualization.qzv')
        result.save(filepath)

        root_dir = str(result.uuid)
        expected = {
            'VERSION',
            'metadata.yaml',
            'data/index.html',
            'data/css/style.css',
            'provenance/metadata.yaml',
            'provenance/VERSION',
            'provenance/action/action.yaml',
            'provenance/artifacts/%s/metadata.yaml' % artifact1.uuid,
            'provenance/artifacts/%s/VERSION' % artifact1.uuid,
            'provenance/artifacts/%s/action/action.yaml' % artifact1.uuid,
            'provenance/artifacts/%s/metadata.yaml' % artifact2.uuid,
            'provenance/artifacts/%s/VERSION' % artifact2.uuid,
            'provenance/artifacts/%s/action/action.yaml' % artifact2.uuid
        }

        self.assertArchiveMembers(filepath, root_dir, expected)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_visualizer_callable_output(self):
        artifact = Artifact.import_data(Mapping, {'foo': 'abc', 'bar': 'def'})

        # Callable returns a value from `return_vals`
        return_vals = (True, False, [], {}, '', 0, 0.0)
        for return_val in return_vals:
            def func(output_dir: str, foo: dict) -> None:
                return return_val

            self.plugin.visualizers.register_function(
                func, {'foo': Mapping}, {}, '', ''
            )
            visualizer = self.plugin.visualizers['func']

            with self.assertRaisesRegex(TypeError, "should not return"):
                visualizer(foo=artifact)

        # Callable returns None (default function return)
        def func(output_dir: str, foo: dict) -> None:
            return None

        self.plugin.visualizers.register_function(
            func, {'foo': Mapping}, {}, '', ''
        )
        visualizer = self.plugin.visualizers['func']

        # Should not raise an exception
        output = visualizer(foo=artifact)
        self.assertIsInstance(output, Results)
        self.assertIsInstance(output.visualization, Visualization)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_async_with_multiple_outputs(self):
        split_ints = self.plugin.methods['split_ints']
        split_ints_markdown = self.plugin.methods['split_ints_markdown']

        artifact = Artifact.import_data(IntSequence1, [0, 42, -2, 43, 6])

        for method in split_ints, split_ints_markdown:
            future = method.async(artifact)

            self.assertIsInstance(future, concurrent.futures.Future)
            result = future.result()

            self.assertIsInstance(result, tuple)
            self.assertEqual(len(result), 2)

            for output_artifact in result:
                self.assertIsInstance(output_artifact, Artifact)
                self.assertEqual(output_artifact.type, IntSequence1)

                self.assertIsInstance(output_artifact.uuid, uuid.UUID)

            # Output artifacts have different UUIDs.
            self.assertNotEqual(result[0].uuid, result[1].uuid)

            # Index lookup.
            self.assertEqual(result[0].view(list), [0, 42])
            self.assertEqual(result[1].view(list), [-2, 43, 6])

            # Test properties of the `Results` object.
            self.assertIsInstance(result, Results)
            self.assertEqual(result.left.view(list), [0, 42])
            self.assertEqual(result.right.view(list), [-2, 43, 6])

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_with_unrecognized_files(self):
        data_dir = os.path.join(self.test_dir.name, 'test')
        os.mkdir(data_dir)
        with open(os.path.join(data_dir, 'file1.txt'), 'w') as fh:
            fh.write('42\n')
        with open(os.path.join(data_dir, 'file2.txt'), 'w') as fh:
            fh.write('43\n')
        nested = os.path.join(data_dir, 'nested')
        os.mkdir(nested)
        with open(os.path.join(nested, 'file3.txt'), 'w') as fh:
            fh.write('44\n')
        with open(os.path.join(nested, 'foo.txt'), 'w') as fh:
            fh.write('45\n')

        error_regex = ("Unrecognized.*foo.txt.*FourIntsDirectoryFormat")
        with self.assertRaisesRegex(ValueError, error_regex):
            Artifact.import_data(FourInts, data_dir)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_import_data_with_invalid_format_multi_file(self):
        data_dir = os.path.join(self.test_dir.name, 'test')
        os.mkdir(data_dir)
        with open(os.path.join(data_dir, 'file1.txt'), 'w') as fh:
            fh.write('42\n')
        with open(os.path.join(data_dir, 'file2.txt'), 'w') as fh:
            fh.write('43\n')
        nested = os.path.join(data_dir, 'nested')
        os.mkdir(nested)
        with open(os.path.join(nested, 'file3.txt'), 'w') as fh:
            fh.write('44\n')
        with open(os.path.join(nested, 'file4.txt'), 'w') as fh:
            fh.write('foo\n')

        error_regex = "file4.txt.*SingleIntFormat"
        with self.assertRaisesRegex(ValueError, error_regex):
            Artifact.import_data(FourInts, data_dir)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_eq_same_uuid(self):
        fp = os.path.join(self.test_dir.name, 'artifact.qza')
        artifact1 = Artifact.import_data(FourInts, [-1, 42, 0, 43])
        artifact1.save(fp)

        artifact2 = Artifact.load(fp)

        self.assertEqual(artifact1, artifact2)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_ne_different_type_same_uuid(self):
        artifact = Artifact.import_data(FourInts, [-1, 42, 0, 43])

        class Faker:
            @property
            def uuid(self):
                return artifact.uuid

        faker = Faker()

        self.assertNotEqual(artifact, faker)

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_peek_artifact(self):
        artifact = Artifact.import_data(FourInts, [0, 0, 42, 1000])
        fp = os.path.join(self.test_dir.name, 'artifact.qza')
        artifact.save(fp)

        metadata = Result.peek(fp)

        self.assertIsInstance(metadata, ResultMetadata)
        self.assertEqual(metadata.type, 'FourInts')
        self.assertEqual(metadata.uuid, str(artifact.uuid))
        self.assertEqual(metadata.format, 'FourIntsDirectoryFormat')

# 需要导入模块: from qiime.sdk import Artifact [as 别名]
# 或者: from qiime.sdk.Artifact import import_data [as 别名]
    def test_load_artifact(self):
        saved_artifact = Artifact.import_data(FourInts, [-1, 42, 0, 43])
        fp = os.path.join(self.test_dir.name, 'artifact.qza')
        saved_artifact.save(fp)

        artifact = Result.load(fp)

        self.assertIsInstance(artifact, Artifact)
        self.assertEqual(artifact.type, FourInts)
        self.assertEqual(artifact.uuid, saved_artifact.uuid)
        self.assertEqual(artifact.view(list), [-1, 42, 0, 43])