#!/usr/bin/env python

# -*- coding: utf-8 -*-

# Convert a DC Council Statute at Large file, for a single statute

# entry, into XML.

#

# python3 make_sal_xml.py A20-003.docx > output/A20-003.xml

# python3 make_sal_xml.py R20-055.docx > output/R20-055.xml

#

# Chome won't normally render an XSLT instruction when loading from a

# file:// URL. To turn off that security restriction, make sure Chrome

# isn't running at all (check if you need to kill it), and then start

# it with this command-line option:

#

# google-chrome --allow-file-access-from-files

import sys, re, lxml.etree as etree, datetime, json

from worddoc import open_docx

from matchers import Matcher, isint, exists

errors = 0

class Para(dict):

return [Para(self._paras, para) for para in self._paras]

has_leading_whitespace = Matcher({'runs': [{'text': re.compile(r'^\s*')}]})

def get_indent(para):

return int(indent)

def pict_handler(node):

return "@@PICT@@"

def parse_file(path_to_file):

return paras

def pipeline(*parsers, final_parser=None):

return _next_parser

def _get_short_title_para(para):

return para.search(lambda para: para['text'].startswith('BE IT ENACTED BY THE COUNCIL'))

short_title_re = re.compile(r'(\u201c|")(?P<short_title>.*?)(\u201d|")')

def header(dom, para, next_parser):

errors = 0

def toc(dom, para, next_parser):

next_parser(body, para)

def short_title(dom, para, next_parser):

para = _get_short_title_para(para)

make_node(dom, 'text', text=para['text'])

next_parser(dom, para.next())

def is_container(prefix):

return Matcher({

'text': re.compile(r'^(?P<prefix>{}) (?P<num>[\w-]+\.) (?P<heading>.+)'.format(prefix), re.I),

})

is_any_container = Matcher({

'text': re.compile(r'^(?P<prefix>(division|title|subtitle|article|subdivision|chapter|subchapter|part|subpart)) (?P<num>[\w-]+\.) (?P<heading>.+)', re.I),

})

def _container(dom, para, next_parser):

next_parser(dom, para)

detect_section = Matcher({'text': re.compile(r'^Sec[,. ;/):-]')})

is_section = Matcher({'text': re.compile(r'^(\u00a7|Sec\.) (?P<num>[\w.-]+)\. (?P<heading>[^\(][^.]+\.(\s[A-Z]|$))?(?P<remainder>.*)')})

def _section(dom, para, next_parser):

next_parser(section_dom, next_para)

is_any_para = Matcher({'text': re.compile(r'^(?P<num>\([\w-]+\)) ?(?P<remainder>.*)')})

def is_para(para):

return _is_para

def _para(dom, para, next_parser):

next_parser(para_dom, next_para)

trailing_quote_re = re.compile(r'"(.?)$')

def is_include(para):

text = para['text']

return bool((text.startswith('"') and (text.count('"') % 2 or trailing_quote_re.search(text))))

def is_include_end(para):

text = para['text']

return bool((trailing_quote_re.search(text) and (text.startswith('"') or text.count('"') % 2)))

def include(dom, para, next_parser):

next_parser(dom, next_para)

is_text = lambda para: not (is_any_para(para) or is_include(para) or is_include_end(para))

def text(dom, para, next_parser):

make_text(dom, text_para, after=True)

def unhandled(dom, para, next_parser):

for para in para.paras:

make_error(dom, para, reason='too confused')

para_parser = pipeline(_para, text, include, 'para_parser')

section = pipeline(

)

container = pipeline(

_container,

section,

)

parser = pipeline(

)

def make_node(parent, tag, text='', **attrs):

return n

def make_container(parent, prefix, num, heading):

return container

def make_section(parent, num, heading=None, **kwargs):

return section

def make_para(parent, num, **kwargs):

para = make_node(parent, 'para', None)

make_node(para, 'num', num)

return para

is_auto_numbered = Matcher({'properties': {'num': exists()}})

def make_text(parent, para, after=None, proof=None, **kwargs):

return make_node(parent, tag, text, proof=proof or after)

def make_error(dom, para, reason=None):

global errors

errors += 1

error_dom = make_node(dom, 'error', para['text'], reason=reason)

def parse(path, save=False):

return dom

if __name__ == '__main__':

dom = parse(sys.argv[1], True)

sys.stdout.buffer.write(etree.tostring(dom, pretty_print=True, encoding="utf-8"))