Python pymei.MeiElement类代码示例

 def add_source(sourceDesc, adi):
     existing = sourceDesc.getDocument().getElementById(adi[3])
     if not existing:
         source = MeiElement('source')
         source.id = adi[3]
         source.addAttribute('type', adi[1])
         sourceDesc.addChild(source)

    def test_getattributeval(self):
        measure = MeiElement("measure")
        staff = MeiElement("staff")
        measure.addAttribute("n", "2")

        self.assertEqual(utilities.get_attribute_val(measure, "n"), "2")
        self.assertEqual(utilities.get_attribute_val(staff, "n", "1"), "1")

 def test_getattributeval(self):
     measure = MeiElement('measure')
     staff = MeiElement('staff')
     measure.addAttribute('n', '2')
     
     self.assertEqual(utilities.get_attribute_val(measure, 'n'), '2')
     self.assertEqual(utilities.get_attribute_val(staff, 'n', '1'), '1')

    def test_object_equality(self):
        el1 = MeiElement("note")
        el2 = MeiElement("accid")

        el1.addChild(el2)

        self.assertEqual(el1, el2.parent)

def make_invisible_space(MEI_tree, handle_mRest=False):
    """Turns all invisible notes, rests and mRests into
    <space> elements.
    """

    all_note_rest = MEI_tree.getDescendantsByName('note rest')
    all_mRest = MEI_tree.getDescendantsByName('mRest')

    # Replace notes and rests with spaces
    for item in all_note_rest:
        try:
            if item.getAttribute('visible').getValue() == 'false':
                space = MeiElement('space')
                attributes = item.getAttributes()
                for attr in attributes:
                    # Don't add octave or pitch attributes to space
                    if attr.getName() not in ['oct', 'pname']:
                        space.addAttribute(attr)
                # If mRest, calculate duration here?
                parent = item.getParent()
                parent.addChildBefore(item, space)
                parent.removeChild(item)
        except:  # doesn't have attribute `visible`
            pass
    # Replace mRests with nothing -- just remove them
    # Not currently supported by MEItoVexFlow
    if handle_mRest:
        for item in all_mRest:
            try:
                if item.getAttribute('visible').getValue() == 'false':
                    item.getParent().removeChild(item)
            except:  # doesn't have attribute `visible`
                pass

    def _create_staff_group(self, sg_list, staff_grp, n):
        '''
        Recursively create the staff group element from the parsed
        user input of the staff groupings
        '''
        if not sg_list:
            return staff_grp, n
        else:
            if type(sg_list[0]) is list:
                new_staff_grp, n = self._create_staff_group(sg_list[0], MeiElement('staffGrp'), n)
                staff_grp.addChild(new_staff_grp)
            else:
                # check for barthrough character
                if sg_list[0][-1] == '|':
                    # the barlines go through all the staves in the staff group
                    staff_grp.addAttribute('barthru', 'true')
                    # remove the barthrough character, should now only be an integer
                    sg_list[0] = sg_list[0][:-1]

                n_staff_defs = int(sg_list[0])
                # get current staffDef number
                for i in range(n_staff_defs):
                    staff_def = MeiElement('staffDef')
                    staff_def.addAttribute('n', str(n + i + 1))
                    staff_grp.addChild(staff_def)
                n += n_staff_defs

            return self._create_staff_group(sg_list[1:], staff_grp, n)

    def post(self, file):
        '''
        Add a dot ornament to a given element.
        '''

        neumeid = str(self.get_argument("id", ""))
        dot_form = str(self.get_argument("dotform", ""))

        # Bounding box
        ulx = str(self.get_argument("ulx", None))
        uly = str(self.get_argument("uly", None))
        lrx = str(self.get_argument("lrx", None))
        lry = str(self.get_argument("lry", None))

        mei_directory = os.path.abspath(conf.MEI_DIRECTORY)
        fname = os.path.join(mei_directory, file)
        self.mei = XmlImport.read(fname)

        punctum = self.mei.getElementById(neumeid)
        # check that a punctum element was provided
        if punctum.getName() == "neume" and punctum.getAttribute("name").getValue() == "punctum":
            note = punctum.getDescendantsByName("note")
            if len(note):
                # if a dot does not already exist on the note
                if len(note[0].getChildrenByName("dot")) == 0:
                    dot = MeiElement("dot")
                    dot.addAttribute("form", dot_form)
                    note[0].addChild(dot)

            self.update_or_add_zone(punctum, ulx, uly, lrx, lry)

        XmlExport.write(self.mei, fname)

        self.set_status(200)

 def _create_graphic_element(self, imgfile):
     graphic = MeiElement("graphic")
     # xlink = MeiNamespace("xlink", "http://www.w3.org/1999/xlink")
     # ns_attr = MeiAttribute("xlink")
     graphic.addAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink")
     graphic.addAttribute("xlink:href", imgfile)
     return graphic

        def parse_token(token):
            def parse_attrs(token):
                def parse_attrs_str(attrs_str):
                    res = []
                    attr_pairs = attrs_str.split(",")
                    for attr_pair in attr_pairs:
                        if attr_pair == '':
                            continue
                        name_val = attr_pair.split("=")
                        if len(name_val) > 1:
                            attr = MeiAttribute(name_val[0], name_val[1])
                            res.append(attr)
                        else:
                            logging.warning("get_descendants(): invalid attribute specifier in expression: " + expr)
                    return res
                m = re.search("\[(.*)\]", token)
                attrs_str = ""
                if m is not None:
                    attrs_str = m.group(1)
                return parse_attrs_str(attrs_str)

            m = re.search("^([^\[]+)", token)
            elem = MeiElement(m.group(1))
            attrs = parse_attrs(token)
            for attr in attrs:
                elem.addAttribute(attr)
            return elem

    def create_zone(self, ulx, uly, lrx, lry):
        zone = MeiElement("zone")
        zone.addAttribute("ulx", ulx)
        zone.addAttribute("uly", uly)
        zone.addAttribute("lrx", lrx)
        zone.addAttribute("lry", lry)

        return zone

 def test_documentwritefailure(self):
     doc = MeiDocument()
     root = MeiElement("mei")
     root.id = "myid"
     doc.root = root
     with self.assertRaises(FileWriteFailureException) as cm:
         ret = XmlExport.meiDocumentToFile(doc, "C:/StupidPath")
     self.assertTrue(isinstance(cm.exception, FileWriteFailureException))

 def add_editor(titleStmt, ali):
     existing = titleStmt.getDocument().getElementById(adi[3])
     if not existing:
         editor = MeiElement('editor')
         editor.id = ali[3]
         # Using 'replace' simply to have more natural name for a person
         editor.addAttribute('type', adi[1].replace('ction', 'ctor'))
         titleStmt.addChild(editor)

    def get_new_zone(self, ulx, uly, lrx, lry):
        zone = MeiElement("zone")
        zone.addAttribute("ulx", str(ulx))
        zone.addAttribute("uly", str(uly))
        zone.addAttribute("lrx", str(lrx))
        zone.addAttribute("lry", str(lry))

        return zone

    def test_exporttostring(self):
        doc = MeiDocument()
        root = MeiElement("mei")
        root.id = "myid"
        doc.root = root

        expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<mei xml:id=\"myid\" xmlns=\"http://www.music-encoding.org/ns/mei\" meiversion=\"2013\" />\n"
        ret = documentToText(doc)
        self.assertEqual(expected, ret)

    def test_setdocument(self):
        m = MeiElement("mei")
        doc = MeiDocument()

        with self.assertRaises(DocumentRootNotSetException) as cm:
            m.setDocument(doc)
        self.assertTrue(isinstance(cm.exception, DocumentRootNotSetException))
        doc.setRootElement(m)

        self.assertEqual(doc.root, m)