comparison jbrowse2.py @ 104:9e3f69d9fed1 draft

planemo upload for repository https://github.com/galaxyproject/tools-iuc/tree/master/tools/jbrowse2 commit a1537aea75fc902d0e38c0b7c698830a939648b1-dirty

103:dc3fe98e7b37

#!/usr/bin/env python

import argparse
import binascii
import datetime
# import hashlib
import json
import logging
import os

            "category": [
                categ,
            ],
            "adapter": {"type": "HicAdapter", "hicLocation": {"uri": uri}},
        }
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_maf(self, data, trackData):
        """
        from https://github.com/cmdcolin/maf2bed
        Note: Both formats start with a MAF as input, and note that your MAF file should contain the species name and chromosome name

                {"type": "LinearArcDisplay", "displayId": "%s-LinearArcDisplay" % tId},
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[gname].append(trackDict)
        self.trackIdlist.append(tId)
        if self.config_json.get("plugins", None):
            self.config_json["plugins"].append(mafPlugin[0])
        else:
            self.config_json.update(mafPlugin)

                }
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_bam(self, data, trackData, bam_indexes=None, **kwargs):
        tId = trackData["label"]
        realFName = trackData["path"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_cram(self, data, trackData, cram_indexes=None, **kwargs):
        tId = trackData["label"]
        realFName = trackData["path"]
        categ = trackData["category"]

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_vcf(self, data, trackData):
        tId = trackData["label"]
        categ = trackData["category"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def _sort_gff(self, data, dest):
        # Only index if not already done
        if not os.path.exists(dest):
            cmd = "jbrowse sort-gff '%s' | bgzip -c > '%s'" % (

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_bed(self, data, ext, trackData):
        tId = trackData["label"]
        categ = trackData["category"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def add_paf(self, data, trackData, pafOpts, **kwargs):
        tname = trackData["name"]
        tId = trackData["label"]
        url = tId

                passnames.append(gname)
            useuri = pafOpts["useuri"] == "true"
            if gname not in self.genome_names:
                # ignore if already there - eg for duplicates among pafs.
                asstrack, first_contig = self.make_assembly(gpath, gname, useuri)
                self.genome_names.append(gname)
                self.tracksToAdd[gname] = []
                self.assemblies.append(asstrack)
                self.ass_first_contigs.append(first_contig)
        trackDict = {
            "type": "SyntenyTrack",
            "trackId": tId,
            "assemblyNames": passnames,
            "category": [

            style_json = {
                "type": "LinearBasicDisplay",
                "displayId": "%s-LinearBasicDisplay" % tId,
            }
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(trackDict)
        self.trackIdlist.append(tId)

    def process_annotations(self, track):
        category = track["category"].replace("__pd__date__pd__", TODAY)
        tt1 = ",/ :;\\"
        tt2 = "______"

                    track["conf"]["options"]["paf"],
                )
            else:
                logging.warning("Do not know how to handle %s", dataset_ext)
            # Return non-human label for use in other fields
            yield outputTrackConfig["label"]

    def add_default_session(self, default_data):
        """
        default session settings are hard and fragile.

            tracks_data = []
            for track_conf in self.tracksToAdd[gnome]:
                tId = track_conf["trackId"]
                if tId in default_data[gnome]["visibility"]["default_on"]:
                    track_types[tId] = track_conf["type"]
                    style_data = default_data[gnome]["style"].get(tId, None)
                    if not style_data:
                        logging.debug(
                            "### No style data for %s in available default data %s"
                            % (tId, default_data)
                        )
                        style_data = {"type": "LinearBasicDisplay"}
                        if "displays" in track_conf:
                            disp = track_conf["displays"][0]["type"]
                            style_data["type"] = disp
                    if track_conf.get("style_labels", None):
                        # TODO fix this: it should probably go in a renderer block (SvgFeatureRenderer) but still does not work
                        # TODO move this to per track displays?
                        style_data["labels"] = track_conf["style_labels"]
                    tracks_data.append(

def parse_style_conf(item):
    if item.text.lower() in ["false", "true", "yes", "no"]:
        return item.text.lower in ("yes", "true")
    else:
        return item.text


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="", epilog="")
    parser.add_argument("--xml", help="Track Configuration")

                                track_conf["useuri"],
                                os.path.realpath(x.attrib["path"]),
                            )
                        )
                    else:
                        if trackfiles:
                            metadata = metadata_from_node(x.find("metadata"))
                            track_conf["dataset_id"] = metadata.get(
                                "dataset_id", "None"
                            )
                            if x.attrib["useuri"].lower() == "yes":
                                tfa = (
                                    x.attrib["path"],
                                    x.attrib["ext"],
                                    x.attrib["useuri"],
                                    track_conf["label"],
                                    metadata,
                                )
                            else:
                                tfa = (
                                    os.path.realpath(x.attrib["path"]),
                                    x.attrib["ext"],
                                    x.attrib["useuri"],
                                    track_conf["label"],
                                    metadata,
                                )
                            track_conf["trackfiles"].append(tfa)

                if is_multi_bigwig:
                    metadata = metadata_from_node(x.find("metadata"))

                    track_conf["trackfiles"].append(

                    )

            track_conf["category"] = track.attrib["cat"]
            track_conf["format"] = track.attrib["format"]
            track_conf["conf"] = etree_to_dict(track.find("options"))
            logging
            keys = jc.process_annotations(track_conf)
            if keys:
                for key in keys:
                    vis = track.attrib.get("visibility", "default_off")
                    if not vis:

                    stile = {}
                    for trak in trakdat:
                        if trak["trackId"] == key:
                            stile = trak.get("style", {})
                    if track.find("options/style"):
                        supdate = {
                            item.tag: parse_style_conf(item)
                            for item in track.find("options/style")
                        }
                        stile.update(supdate)
                    default_session_data[primaryGenome]["style"][key] = stile
                    if track.find("options/style_labels"):
                        default_session_data[primaryGenome]["style_labels"][key] = {
                            item.tag: parse_style_conf(item)
                            for item in track.find("options/style_labels")

        "tertiary_color": root.find("metadata/general/tertiary_color").text,
        "quaternary_color": root.find("metadata/general/quaternary_color").text,
        "font_size": root.find("metadata/general/font_size").text,
    }
    jc.add_general_configuration(general_data)
    trackconf = jc.config_json.get("tracks", [])
    for gnome in jc.genome_names:
        gtracks = jc.tracksToAdd[gnome]
        if len(gtracks) > 0:
            logging.debug(

            jc.trackIdlist,
            json.dumps(trackconf, indent=2),
        )
    )
    jc.write_config()
    jc.add_default_session(default_session_data)
    # note that this can be left in the config.json but has NO EFFECT if add_defsess_to_index is called.
    # jc.add_defsess_to_index(default_session_data)
    # jc.text_index() not sure what broke here.

104:9e3f69d9fed1

#!/usr/bin/env python

import argparse
import binascii
import copy
import datetime
# import hashlib
import json
import logging
import os

            "category": [
                categ,
            ],
            "adapter": {"type": "HicAdapter", "hicLocation": {"uri": uri}},
        }
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_maf(self, data, trackData):
        """
        from https://github.com/cmdcolin/maf2bed
        Note: Both formats start with a MAF as input, and note that your MAF file should contain the species name and chromosome name

                {"type": "LinearArcDisplay", "displayId": "%s-LinearArcDisplay" % tId},
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[gname].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))
        if self.config_json.get("plugins", None):
            self.config_json["plugins"].append(mafPlugin[0])
        else:
            self.config_json.update(mafPlugin)

                }
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_bam(self, data, trackData, bam_indexes=None, **kwargs):
        tId = trackData["label"]
        realFName = trackData["path"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_cram(self, data, trackData, cram_indexes=None, **kwargs):
        tId = trackData["label"]
        realFName = trackData["path"]
        categ = trackData["category"]

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_vcf(self, data, trackData):
        tId = trackData["label"]
        categ = trackData["category"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def _sort_gff(self, data, dest):
        # Only index if not already done
        if not os.path.exists(dest):
            cmd = "jbrowse sort-gff '%s' | bgzip -c > '%s'" % (

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_bed(self, data, ext, trackData):
        tId = trackData["label"]
        categ = trackData["category"]
        useuri = trackData["useuri"].lower() == "yes"

                },
            ],
        }
        style_json = self._prepare_track_style(trackDict)
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def add_paf(self, data, trackData, pafOpts, **kwargs):
        tname = trackData["name"]
        tId = trackData["label"]
        url = tId

                passnames.append(gname)
            useuri = pafOpts["useuri"] == "true"
            if gname not in self.genome_names:
                # ignore if already there - eg for duplicates among pafs.
                asstrack, first_contig = self.make_assembly(gpath, gname, useuri)
                self.genome_names.append(copy.copy(gname))
                self.tracksToAdd[gname] = []
                self.assemblies.append(copy.copy(asstrack))
                self.ass_first_contigs.append(copy.copy(first_contig))
        trackDict = {
            "type": "SyntenyTrack",
            "trackId": tId,
            "assemblyNames": passnames,
            "category": [

            style_json = {
                "type": "LinearBasicDisplay",
                "displayId": "%s-LinearBasicDisplay" % tId,
            }
        trackDict["style"] = style_json
        self.tracksToAdd[trackData["assemblyNames"]].append(copy.copy(trackDict))
        self.trackIdlist.append(copy.copy(tId))

    def process_annotations(self, track):
        category = track["category"].replace("__pd__date__pd__", TODAY)
        tt1 = ",/ :;\\"
        tt2 = "______"

                    track["conf"]["options"]["paf"],
                )
            else:
                logging.warning("Do not know how to handle %s", dataset_ext)
            # Return non-human label for use in other fields
            logging.debug("### processanno ext=%s trackstoadd = %s" % (dataset_ext, self.tracksToAdd))
            yield outputTrackConfig["label"]

    def add_default_session(self, default_data):
        """
        default session settings are hard and fragile.

            tracks_data = []
            for track_conf in self.tracksToAdd[gnome]:
                tId = track_conf["trackId"]
                if tId in default_data[gnome]["visibility"]["default_on"]:
                    track_types[tId] = track_conf["type"]
                    style_data = default_data[gnome]["style"].get(tId, {})
                    if not style_data:
                        logging.debug(
                            "No style data for %s in available default data %s"
                            % (tId, default_data)
                        )
                    else:
                        logging.debug(
                            "style data for %s = %s"
                            % (tId, style_data)
                        )

                    if style_data.get('type',None):
                        style_data["type"] = "LinearBasicDisplay"
                    if "displays" in track_conf:
                        disp = track_conf["displays"][0]["type"]
                        style_data["type"] = disp
                    if track_conf.get("style_labels", None):
                        # TODO fix this: it should probably go in a renderer block (SvgFeatureRenderer) but still does not work
                        # TODO move this to per track displays?
                        style_data["labels"] = track_conf["style_labels"]
                    tracks_data.append(

def parse_style_conf(item):
    if item.text.lower() in ["false", "true", "yes", "no"]:
        return item.text.lower in ("yes", "true")
    elif item.text.isdigit():
        return int(item.text)
    return item.text


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="", epilog="")
    parser.add_argument("--xml", help="Track Configuration")

                                track_conf["useuri"],
                                os.path.realpath(x.attrib["path"]),
                            )
                        )
                    else:
                        metadata = metadata_from_node(x.find("metadata"))
                        track_conf["dataset_id"] = metadata.get(
                            "dataset_id", "None"
                        )
                        if x.attrib["useuri"].lower() == "yes":
                            tfa = (
                                x.attrib["path"],
                                x.attrib["ext"],
                                x.attrib["useuri"],
                                track_conf["label"],
                                metadata,
                            )
                        else:
                            tfa = (
                                os.path.realpath(x.attrib["path"]),
                                x.attrib["ext"],
                                x.attrib["useuri"],
                                track_conf["label"],
                                metadata,
                            )
                        track_conf["trackfiles"].append(tfa)

                if is_multi_bigwig:
                    metadata = metadata_from_node(x.find("metadata"))

                    track_conf["trackfiles"].append(

                    )

            track_conf["category"] = track.attrib["cat"]
            track_conf["format"] = track.attrib["format"]
            track_conf["conf"] = etree_to_dict(track.find("options"))
            keys = jc.process_annotations(track_conf)
            if keys:
                for key in keys:
                    vis = track.attrib.get("visibility", "default_off")
                    if not vis:

                    stile = {}
                    for trak in trakdat:
                        if trak["trackId"] == key:
                            stile = trak.get("style", {})
                    if track.find("options/style"):
                        for item in track.find("options/style"):
                            if item.text:
                                stile[item.tag] = parse_style_conf(item)
                    logging.debug("stile=%s" % stile)
                    default_session_data[primaryGenome]["style"][key] = stile
                    if track.find("options/style_labels"):
                        default_session_data[primaryGenome]["style_labels"][key] = {
                            item.tag: parse_style_conf(item)
                            for item in track.find("options/style_labels")

        "tertiary_color": root.find("metadata/general/tertiary_color").text,
        "quaternary_color": root.find("metadata/general/quaternary_color").text,
        "font_size": root.find("metadata/general/font_size").text,
    }
    jc.add_general_configuration(general_data)
    jc.add_default_session(default_session_data)
    trackconf = jc.config_json.get("tracks", [])
    for gnome in jc.genome_names:
        gtracks = jc.tracksToAdd[gnome]
        if len(gtracks) > 0:
            logging.debug(

            jc.trackIdlist,
            json.dumps(trackconf, indent=2),
        )
    )
    jc.write_config()
    # note that this can be left in the config.json but has NO EFFECT if add_defsess_to_index is called.
    # jc.add_defsess_to_index(default_session_data)
    # jc.text_index() not sure what broke here.