def test_parms_renaming_deprecated_parms(s):
        outDir = outDirBase + '_renamingDeprecatedParms/'

        opts = [
            # parms renaming deprecated parms
            "--outputDirectory",
            outDir,
            "--firstAttribute",
            "mutated/not",
            "--layoutName",
            "layout",
            "--noLayoutIndependentStats",
            "--noLayoutAwareStats",
            "--distanceMetric",
            "cosine",
            "--outputTar",
            os.path.join(outDir, 'tar.tar'),
            "--outputZip",
            os.path.join(outDir, 'zip.zip'),
            "--authGroup",
            "myRole",
            "--colorAttributeFile",
            attsStringsFile,
            "--neighborCount",
            "9",
            "--feature_space",
            rawDataFile
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(
            s, expParmDir, outDir,
            ['log', 'meta.json', 'mapMeta.json', 'tar.tar', 'zip.zip'])
Пример #2
0
    def test_sim6Layout_check(s):
        '''
        This test insures that if you start from the same data,
          the output does not depend on the input form

        '''
        outDir = outDirBase + '_top6/'

        #opts for compute sparse to create a sparse top 6 spearman
        optsSparsSim = [
            '--in_file', rawDataFile,
            '--metric', 'spearman',
            '--output_type', 'SPARSE',
            '--top', '6',
            '--out_file', outSim6File,
            '--num_jobs', '2'
        ]
        compute_sparse_matrix.main(optsSparsSim)

        optsLayoutSparse = [
            "--similarity", outSim6File,
            "--names", "layout",
            "--scores", attsCodedFile,
            "--colormaps", colorDataFile,
            "--directory", outDir,
            "--include-singletons",
            "--no_layout_independent_stats",
            "--no_layout_aware_stats"]

        util.removeOldOutFiles(outDir)
        layout.main(optsLayoutSparse)
        util.compareActualVsExpectedDir(s, expDir, outDir)
    def test_coordinates_layout_parms_renamed(s):
        outDir = outDirBase + '_coordinates_layout_parms_renamed/'

        opts = [
            "--coordinates", coordDataFile, "--layoutName", "layout",
            "--distanceMetric", 'spearman', "--outputDirectory", outDir,
            "--noLayoutIndependentStats", "--noLayoutAwareStats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)

        #check that it is mostly the same as the other files
        util.compareActualVsExpectedDir(s,
                                        expNoAttsDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'neighbors_0.tab',
                                            'assignments0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        #theese files are not expected to be the same as other runs,
        # but to make sure they are correct we have but previous runs in a different
        # expected directory.
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)
    def test_xy(s):
        outDir = outDirBase + '_xy/'

        opts = [
            "--coordinates", coordDataFile, "--names", "layout", "--metric",
            'spearman', "--scores", attsCodedFile, "--colormaps",
            colorDataFile, "--directory", outDir, "--include-singletons",
            "--no_layout_independent_stats", "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)

        layout.main(opts)
        #check that it is mostly the same as the other files
        util.compareActualVsExpectedDir(s,
                                        expDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'mapMeta.json',
                                            'assignments0.tab',
                                            'neighbors_0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)
    def test_xy_no_color(s):
        outDir = outDirBase + '_xy_no_color/'

        opts = [
            "--coordinates", coordDataFile, "--scores", attsStringsFile,
            "--names", "layout", "--directory", outDir, "--include-singletons",
            "--no_layout_independent_stats", "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)

        layout.main(opts)
        #check that it is mostly the same as the other files
        util.compareActualVsExpectedDir(s,
                                        expNoColorDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'assignments0.tab',
                                            'neighbors_0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        #theese files are not expected to be the same as other runs,
        # but to make sure they are correct we have but previous runs in a different
        # expected directory.
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)
Пример #6
0
    def test_xy_no_colorMakeMapUIfiles(s):
        outDir = outDirBase + '_xy_no_color/'

        opts = Namespace(coordinates=[coordDataFile],
                         scores=[attsStringsFile],
                         names=["layout"],
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=False,
                         mutualinfo=False,
                         associations=False)

        util.removeOldOutFiles(outDir)

        layout.makeMapUIfiles(opts)
        #check that it is mostly the same as the other files
        util.compareActualVsExpectedDir(s,
                                        expNoColorDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'assignments0.tab',
                                            'neighbors_0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        #theese files are not expected to be the same as other runs,
        # but to make sure they are correct we have but previous runs in a different
        # expected directory.
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)
Пример #7
0
    def test_xy_no_attsfromMakeUI(s):
        outDir = outDirBase + '_xy_no_atts/'

        opts = Namespace(coordinates=[coordDataFile],
                         names=["layout"],
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=True,
                         mutualinfo=True,
                         associations=True)

        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s,
                                        expNoAttsDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'mapMeta.json',
                                            'neighbors_0.tab',
                                            'assignments0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)
Пример #8
0
    def test_xy(s):
        outDir = outDirBase + '_xy/'

        opts = Namespace(
            layoutInputFile= [coordDataFile],
            names= ["layout"],
            metric= 'spearman',
            scores= [attsCodedFile],
            colormaps= colorDataFile,
            directory= outDir,
            singletons=True,
            clumpinessStats=False,
            mutualinfo=False,
            associations=False
        )

        util.removeOldOutFiles(outDir)

        layout.makeMapUIfiles(opts)
        #check that it is mostly the same as the other files
        util.compareActualVsExpectedDir(s,expDir, outDir,
                                        excludeFiles = ['log',
                                                        'mapMeta.json',
                                                        'neighbors_0.tab',
                                                        'assignments0.tab',
                                                        'hexNames.tab',
                                                        'xyPreSquiggle_0.tab']
                                        )
        util.compareActualVsExpectedFile(s,'assignments0.tab',expXyDir,outDir)
        util.compareActualVsExpectedFile(s,'xyPreSquiggle_0.tab',expXyDir,outDir)
    def test_deprecated_parms_renamed(s):
        outDir = outDirBase + '_deprecatedParmsRenamed/'

        opts = [
            # parms deprecated in favor of new names
            "--directory",
            outDir,
            "--first_attribute",
            "mutated/not",
            "--names",
            "layout",
            "--no_layout_independent_stats",
            "--no_layout_aware_stats",
            "--metric",
            "cosine",
            "--output_tar",
            os.path.join(outDir, 'tar.tar'),
            "--output_zip",
            os.path.join(outDir, 'zip.zip'),
            "--role",
            "myRole",
            "--scores",
            attsStringsFile,
            "--truncation_edges",
            "9",
            "--feature_space",
            rawDataFile
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(
            s, expParmDir, outDir,
            ['log', 'meta.json', 'mapMeta.json', 'tar.tar', 'zip.zip'])
Пример #10
0
    def test_raw_no_atts(s):
        outDir = outDirBase + '_raw_no_atts/'

        opts = [
            "--feature_space", rawDataFile, "--names", "layout", "--metric",
            'spearman', "--directory", outDir, "--include-singletons",
            "--no_layout_independent_stats", "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #11
0
 def test_group_meta_json_view_no_group_dir(s):
     outDir = os.path.join(outDirBase, 'groupMetaCalcNoGroup/view/baseMap')
     opts = [
         "--layoutInputFile",
         os.path.join(inDir, 'similarity.tab'), "--layoutInputFormat",
         'sparseSimilarity', "--layoutName", "layout", "--role", "myRole",
         "--outputDirectory", outDir, "--noLayoutIndependentStats",
         "--noLayoutAwareStats"
     ]
     util.removeOldOutFiles(outDir)
     layout.main(opts)
     util.compareActualVsExpectedFile(s, 'meta.json', expMetaDir, outDir)
Пример #12
0
    def test_top6_no_color(s):
        outDir = outDirBase + '_top6_no_color/'

        opts = [
            "--scores", attsStringsFile, "--similarity", top6SimDataFile,
            "--names", "layout", "--directory", outDir, "--include-singletons",
            "--no_layout_independent_stats", "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoColorDir, outDir)
Пример #13
0
    def test_raw_layout_parms_renamed(s):
        outDir = outDirBase + '_raw_layout_parms_renamed/'

        opts = [
            "--feature_space", rawDataFile, "--layoutName", "layout",
            "--distanceMetric", 'spearman', "--outputDirectory", outDir,
            "--noLayoutIndependentStats", "--noLayoutAwareStats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #14
0
    def test_parms_renaming_full_layout(s):
        outDir = outDirBase + 'parms_renaming_full_layout/'

        opts = [
            "--layoutInputFile", fullSimDataFile, "--layoutInputFormat",
            "fullSimilarity", "--layoutName", "layout", "--distanceMetric",
            'spearman', "--outputDirectory", outDir,
            "--noLayoutIndependentStats", "--noLayoutAwareStats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #15
0
    def test_top6_no_attsfromMakeUIfiles(s):
        outDir = outDirBase + '_top6_no_atts/'

        opts = Namespace(similarity=[top6SimDataFile],
                         names=["layout"],
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=True,
                         mutualinfo=True,
                         associations=True)
        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #16
0
    def test_renaming_2_raw_layout(s):
        outDir = outDirBase + '_renaming_2_raw_layout/'

        opts = [
            "--layoutInputFile", rawDataFile, "--layoutInputFile",
            rawDataFile_2, "--layoutInputFormat", 'clusterData',
            "--layoutName", "layout", "--layoutName", "layout_2",
            "--distanceMetric", 'spearman', "--outputDirectory", outDir,
            "--noLayoutIndependentStats", "--noLayoutAwareStats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoAtts2Dir, outDir)
Пример #17
0
    def test_raw_no_attsfromMakeUIfiles(s):
        outDir = outDirBase + '_raw_no_atts/'

        opts = Namespace(feature_space=[rawDataFile],
                         names=["layout"],
                         metric='spearman',
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=True,
                         mutualinfo=True,
                         associations=True)

        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #18
0
 def test_map_meta_json_non_standard(s):
     outDir = os.path.join(outDirBase, 'mapMetaCalcNonStandard')
     opts = [
         "--layoutInputFile",
         os.path.join(inDir, 'full_matrix.tab'), "--layoutInputFile",
         os.path.join(inDir, 'full_matrix_2.tab'), "--layoutInputFormat",
         'clusterData', "--layoutName", "layout", "--layoutName",
         "layout_2", "--outputDirectory", outDir,
         "--noLayoutIndependentStats", "--noLayoutAwareStats"
     ]
     util.removeOldOutFiles(outDir)
     layout.main(opts)
     util.compareActualVsExpectedFile2(
         s, os.path.join(expMetaDir, 'mapMetaEmpty.json'),
         os.path.join(outDir, 'mapMeta.json'))
Пример #19
0
    def test_full_no_colorfromMakeUIfiles(s):
        outDir = outDirBase + '_full_no_color/'

        opts = Namespace(similarity_full=[fullSimDataFile],
                         names=["layout"],
                         scores=[attsStringsFile],
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=False,
                         mutualinfo=False,
                         associations=False)

        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expNoColorDir, outDir)
Пример #20
0
    def test_no_feature_file(s):
        outDir = outDirBase + '_junk/'

        opts = [
            "--names", "layout", "--metric", 'spearman', "--directory", outDir,
            "--include-singletons", "--no_layout_independent_stats",
            "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        try:
            rc = 0
            rc = layout.main(opts)
            s.assertTrue(rc, 'this should have failed')
        except ValueError as e:
            s.assertTrue(e, e)
Пример #21
0
    def test_rawfromMakeUIfiles(s):
        outDir = outDirBase + '_raw/'

        opts = Namespace(feature_space=[rawDataFile],
                         names=["layout"],
                         metric='spearman',
                         scores=[attsCodedFile],
                         colormaps=colorDataFile,
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=False,
                         mutualinfo=False,
                         associations=False)
        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expDir, outDir)
Пример #22
0
 def test_map_meta_json_standard_simple(s):
     inDir = os.path.join(testDir, 'in/dataRoot/featureSpace/simpleMapName')
     outDir = os.path.join(outDirBase, 'mapMetaCalcStandardSimple')
     opts = [
         "--layoutInputFile",
         os.path.join(inDir, 'full_matrix.tab'), "--layoutInputFile",
         os.path.join(inDir, 'full_matrix_2.tab'), "--layoutInputFormat",
         'clusterData', "--layoutName", "layout", "--layoutName",
         "layout_2", "--outputDirectory", outDir,
         "--noLayoutIndependentStats", "--noLayoutAwareStats"
     ]
     util.removeOldOutFiles(outDir)
     layout.main(opts)
     util.compareActualVsExpectedFile2(
         s, os.path.join(expMetaDir, 'mapMetaSimple.json'),
         os.path.join(outDir, 'mapMeta.json'))
Пример #23
0
    def test_top6fromMakeUIfiles(s):
        outDir = outDirBase + '_top6/'

        opts = Namespace(similarity=[top6SimDataFile],
                         names=["layout"],
                         scores=[attsCodedFile],
                         colormaps=colorDataFile,
                         directory=outDir,
                         singletons=True,
                         clumpinessStats=False,
                         mutualinfo=False,
                         associations=False)

        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expDir, outDir)
Пример #24
0
    def test_fullfromMakeUIfiles(s):
        outDir = outDirBase + '_full/'

        #options for different layout.py executions
        opts = Namespace(
            layoutInputFile = [fullSimDataFile],
            names = ["layout"],
            scores = [attsCodedFile],
            colormaps = colorDataFile,
            directory = outDir,
            singletons = True,
            clumpinessStats=False,
            mutualinfo=False,
            associations=False
        )

        util.removeOldOutFiles(outDir)
        layout.makeMapUIfiles(opts)
        util.compareActualVsExpectedDir(s, expDir, outDir)
Пример #25
0
    def test_full(s):
        outDir = outDirBase + '_full/'

        #opts for compute sparse to create a full spearman
        opts = [
            '--in_file', rawDataFile, '--metric', 'spearman', '--output_type',
            'full', '--out_file', fullSimDataFile, '--num_jobs', '2'
        ]

        compute_sparse_matrix.main(opts)

        #options for different layout.py executions
        opts = [
            "--similarity_full", fullSimDataFile, "--names", "layout",
            "--scores", attsCodedFile, "--colormaps", colorDataFile,
            "--directory", outDir, "--include-singletons",
            "--no_layout_independent_stats", "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expDir, outDir)
Пример #26
0
    def test_constants_replacing_deprecated_parms(s):
        outDir = outDirBase + '_constantsReplacingdeprecatedParms/'

        opts = [
            # deprecated parms replaced with constant values
            #"--directed_graph",
            #"--include-singletons",
            #"--window_size", "9999",

            # unchanged parms:
            "--feature_space",
            rawDataFile,
            "--names",
            "layout",
            "--directory",
            outDir,
            "--no_layout_independent_stats",
            "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s, expNoAttsDir, outDir)
Пример #27
0
    def runPy(s):

        # Build the parms to be passed to layout.py
        opts = [
            '--similarity',
            inDir + 'artificial_sparse.tab',
            '--names',
            'mRNA',
            '--scores',
            inDir + 'attributes.tabstringed',
            '--colormaps',
            inDir + 'colormaps.tab',
            '--first_attribute',
            'Subtype',
            '--directory',
            outDir,
        ]

        #clear output directory
        util.removeOldOutFiles(outDir)

        # Run the layout
        layout.main(opts)
Пример #28
0
    def test_xy_no_atts(s):
        outDir = outDirBase + '_xy_no_atts/'

        opts = [
            "--coordinates", coordDataFile, "--names", "layout", "--directory",
            outDir, "--include-singletons", "--no_layout_independent_stats",
            "--no_layout_aware_stats"
        ]

        util.removeOldOutFiles(outDir)
        layout.main(opts)
        util.compareActualVsExpectedDir(s,
                                        expNoAttsDir,
                                        outDir,
                                        excludeFiles=[
                                            'log', 'mapMeta.json',
                                            'neighbors_0.tab',
                                            'assignments0.tab', 'hexNames.tab',
                                            'xyPreSquiggle_0.tab'
                                        ])
        util.compareActualVsExpectedFile(s, 'assignments0.tab', expXyDir,
                                         outDir)
        util.compareActualVsExpectedFile(s, 'xyPreSquiggle_0.tab', expXyDir,
                                         outDir)