songs-commented.schema:

   # Re-usable nodes definitions
"""structures:"""
  
     # Opens the "songs" XML node.
     # The left side of ":" is empty, this statement won't produce any node.
"""  :songs()"""
  
       # Let's break down this statement.
       # "song:song"
       #   - Defines a node labeled "Song",
       #   - Maps it with the "song" XML node.
       # "id:->id"
       #   - Adds an "id" attribute.
       #   - Its path is empty (":{path}->").
       #   - Its return type is "id", which is a special type.
       #   - When no path is defined, this acts similar to "serial" or "auto_increment" in SQL databases.
       # "title:title->string" adds a "title" attribute.
       #   - Its path "title" maps the homonymous XML node <title>.
       #   - Return type is "string", which will convert the content of <title> accordingly.
       # ":#{parseTags, tags:@tags->string}->idem as Tags"
       #   - Calls function "parseTags", which splits space-separated
       #     tags in a list.
       #   - Parameter 'tags' is passed with content of attribute 'tags' (@tags), which itself is a string
       #   - Return type of function is left untouched using 'idem'.
       #   - No identifier is specified before the first ":", this statement won't add a new attribute.
       #   - Final result is put in a variable named "Tags"
       # "[]" declares this node as a collection, X2C will iterate over its elements
"""    Song:song(id:->id, title:title->string, :#{parseTags, tags:@tags->string}->idem as Tags)[]"""

         # Defines a node labeled "Artist", mapped to XML node "artist".
         # "id"
         #   - Attribute is auto-generated.
         # "name:_->string"
         #   - Adds a "name" attribute using current node content ('_')
         #   - Of type string.
"""      Artist:artist(id:->id, name:_->string)"""

           # Defines a relationship "AUTHORED"
           #   - Between node "Artist" with id "${ArtistId}",
           #   - And node "Song" with id "${SongId}".
           #   - These variables were automatically mapped using type "id" in their respective nodes.
"""        Artist(id:${ArtistId}->id)-[AUTHORED()]->Song(id:${SongId}->id)"""

         # Tag:${Tags}
         #   - Defines a node labeled "Tag"
         #   - Mapped to our previously generated list of tags.
         # "name"
         #   - Attribute uses the immediate value ('_') of each item in the tag collection.
         # "@MERGE"
         #   - Option will generate "MERGE" commands instead of default "CREATE" ones
"""      Tag:${Tags}(id:->id, name:_->string)[]@MERGE"""

           # Defines a relationship "HAS_TAG" between Song and Tag nodes.
"""        Song(id:${SongId}->id)-[HAS_TAG()]->Tag(id:${TagId}->id)"""
      
   # Main content -- what actually gets processed
"""schema:"""

     # Use previously-defined nodes.
     # In this simple example, the node definition could be written directly in schema, this is meant only for illustrative purposes.
"""  :songs()->songs()"""

songs.py:

#!/usr/bin/env python

# Xml : dictionary mapping
import xmltodict
# X2C
import CypherWriter
import Xml2Cypher

def parseTags(params):
  return params['tags'].split(' ')

def main():
  x2c = Xml2Cypher.parse('songs.schema')
  
  nodeWriter = CypherWriter.CypherWriter('songs-nodes.cql')
  rsWriter = CypherWriter.CypherWriter('songs-relationships.cql')
  
  # CAPEC XML definitions
  capecXMLFile = 'songs.xml'
  capecXMLEncoding = 'utf8'

  # Load XML file into a dictionary object
  with open(capecXMLFile, encoding=capecXMLEncoding) as fd:
    root = xmltodict.parse(fd.read())
    
    x2c.apply(root, nodeWriter, rsWriter, { 'parseTags': parseTags })
  
  nodeWriter.close()
  rsWriter.close()

main()