northpost-parser 1.1.0__py3-none-any.whl

northpost_parser/__init__.py

@@ -0,0 +1,23 @@
+"""Canadian postal address parsing."""
+
+from .models import (
+    AddressComponents,
+    AddressType,
+    NormalizationStrategy,
+    ParsingMode,
+    ParsingStrategy,
+)
+from .normalizer import AddressNormalizer
+from .service import AddressParserService, BatchStatistics, ParsingResult
+
+__all__ = [
+    "AddressComponents",
+    "AddressNormalizer",
+    "AddressParserService",
+    "AddressType",
+    "BatchStatistics",
+    "NormalizationStrategy",
+    "ParsingMode",
+    "ParsingResult",
+    "ParsingStrategy",
+]

northpost_parser/generated/CanadianAddressLexer.py

@@ -0,0 +1,91 @@
+# Generated from CanadianAddress.g4 by ANTLR 4.13.2
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,14,87,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,
+        6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,
+        7,13,2,14,7,14,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,4,1,40,8,1,11,1,12,
+        1,41,1,2,1,2,1,2,5,2,47,8,2,10,2,12,2,50,9,2,1,3,1,3,4,3,54,8,3,
+        11,3,12,3,55,1,4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,
+        1,10,1,11,1,11,1,12,1,12,1,12,3,12,77,8,12,1,13,4,13,80,8,13,11,
+        13,12,13,81,1,14,1,14,1,14,1,14,0,0,15,1,1,3,2,5,3,7,4,9,0,11,5,
+        13,6,15,7,17,8,19,9,21,10,23,11,25,12,27,13,29,14,1,0,6,2,0,65,90,
+        97,122,1,0,48,57,4,0,39,39,45,46,48,57,8217,8217,3,0,65,90,97,122,
+        192,383,2,0,10,10,13,13,2,0,9,9,32,32,92,0,1,1,0,0,0,0,3,1,0,0,0,
+        0,5,1,0,0,0,0,7,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,
+        17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,
+        27,1,0,0,0,0,29,1,0,0,0,1,31,1,0,0,0,3,39,1,0,0,0,5,43,1,0,0,0,7,
+        53,1,0,0,0,9,57,1,0,0,0,11,59,1,0,0,0,13,61,1,0,0,0,15,63,1,0,0,
+        0,17,65,1,0,0,0,19,67,1,0,0,0,21,69,1,0,0,0,23,71,1,0,0,0,25,76,
+        1,0,0,0,27,79,1,0,0,0,29,83,1,0,0,0,31,32,7,0,0,0,32,33,7,1,0,0,
+        33,34,7,0,0,0,34,35,7,1,0,0,35,36,7,0,0,0,36,37,7,1,0,0,37,2,1,0,
+        0,0,38,40,7,1,0,0,39,38,1,0,0,0,40,41,1,0,0,0,41,39,1,0,0,0,41,42,
+        1,0,0,0,42,4,1,0,0,0,43,48,3,9,4,0,44,47,3,9,4,0,45,47,7,2,0,0,46,
+        44,1,0,0,0,46,45,1,0,0,0,47,50,1,0,0,0,48,46,1,0,0,0,48,49,1,0,0,
+        0,49,6,1,0,0,0,50,48,1,0,0,0,51,54,3,9,4,0,52,54,7,1,0,0,53,51,1,
+        0,0,0,53,52,1,0,0,0,54,55,1,0,0,0,55,53,1,0,0,0,55,56,1,0,0,0,56,
+        8,1,0,0,0,57,58,7,3,0,0,58,10,1,0,0,0,59,60,5,47,0,0,60,12,1,0,0,
+        0,61,62,5,45,0,0,62,14,1,0,0,0,63,64,5,46,0,0,64,16,1,0,0,0,65,66,
+        5,44,0,0,66,18,1,0,0,0,67,68,5,38,0,0,68,20,1,0,0,0,69,70,5,40,0,
+        0,70,22,1,0,0,0,71,72,5,41,0,0,72,24,1,0,0,0,73,74,5,13,0,0,74,77,
+        5,10,0,0,75,77,7,4,0,0,76,73,1,0,0,0,76,75,1,0,0,0,77,26,1,0,0,0,
+        78,80,7,5,0,0,79,78,1,0,0,0,80,81,1,0,0,0,81,79,1,0,0,0,81,82,1,
+        0,0,0,82,28,1,0,0,0,83,84,9,0,0,0,84,85,1,0,0,0,85,86,6,14,0,0,86,
+        30,1,0,0,0,8,0,41,46,48,53,55,76,81,1,6,0,0
+    ]
+
+class CanadianAddressLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    POSTAL_CODE = 1
+    NUMBER = 2
+    WORD = 3
+    ALPHANUMERIC = 4
+    SLASH = 5
+    HYPHEN = 6
+    DOT = 7
+    COMMA = 8
+    AMPERSAND = 9
+    LPAREN = 10
+    RPAREN = 11
+    NL = 12
+    WS = 13
+    CATCHALL = 14
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'/'", "'-'", "'.'", "','", "'&'", "'('", "')'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "POSTAL_CODE", "NUMBER", "WORD", "ALPHANUMERIC", "SLASH", "HYPHEN", 
+            "DOT", "COMMA", "AMPERSAND", "LPAREN", "RPAREN", "NL", "WS", 
+            "CATCHALL" ]
+
+    ruleNames = [ "POSTAL_CODE", "NUMBER", "WORD", "ALPHANUMERIC", "LETTER", 
+                  "SLASH", "HYPHEN", "DOT", "COMMA", "AMPERSAND", "LPAREN", 
+                  "RPAREN", "NL", "WS", "CATCHALL" ]
+
+    grammarFileName = "CanadianAddress.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.13.2")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

northpost_parser/generated/CanadianAddressParser.py

@@ -0,0 +1,531 @@
+# Generated from CanadianAddress.g4 by ANTLR 4.13.2
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+	from typing import TextIO
+else:
+	from typing.io import TextIO
+
+def serializedATN():
+    return [
+        4,1,14,78,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,1,0,5,
+        0,14,8,0,10,0,12,0,17,9,0,1,0,1,0,5,0,21,8,0,10,0,12,0,24,9,0,1,
+        0,1,0,1,1,1,1,1,1,1,1,5,1,32,8,1,10,1,12,1,35,9,1,1,2,1,2,5,2,39,
+        8,2,10,2,12,2,42,9,2,1,2,5,2,45,8,2,10,2,12,2,48,9,2,1,3,5,3,51,
+        8,3,10,3,12,3,54,9,3,1,3,1,3,5,3,58,8,3,10,3,12,3,61,9,3,1,4,1,4,
+        5,4,65,8,4,10,4,12,4,68,9,4,1,4,5,4,71,8,4,10,4,12,4,74,9,4,1,5,
+        1,5,1,5,0,0,6,0,2,4,6,8,10,0,2,1,0,12,13,1,0,1,11,80,0,15,1,0,0,
+        0,2,27,1,0,0,0,4,36,1,0,0,0,6,52,1,0,0,0,8,62,1,0,0,0,10,75,1,0,
+        0,0,12,14,7,0,0,0,13,12,1,0,0,0,14,17,1,0,0,0,15,13,1,0,0,0,15,16,
+        1,0,0,0,16,18,1,0,0,0,17,15,1,0,0,0,18,22,3,2,1,0,19,21,7,0,0,0,
+        20,19,1,0,0,0,21,24,1,0,0,0,22,20,1,0,0,0,22,23,1,0,0,0,23,25,1,
+        0,0,0,24,22,1,0,0,0,25,26,5,0,0,1,26,1,1,0,0,0,27,33,3,6,3,0,28,
+        29,3,4,2,0,29,30,3,6,3,0,30,32,1,0,0,0,31,28,1,0,0,0,32,35,1,0,0,
+        0,33,31,1,0,0,0,33,34,1,0,0,0,34,3,1,0,0,0,35,33,1,0,0,0,36,46,5,
+        12,0,0,37,39,5,13,0,0,38,37,1,0,0,0,39,42,1,0,0,0,40,38,1,0,0,0,
+        40,41,1,0,0,0,41,43,1,0,0,0,42,40,1,0,0,0,43,45,5,12,0,0,44,40,1,
+        0,0,0,45,48,1,0,0,0,46,44,1,0,0,0,46,47,1,0,0,0,47,5,1,0,0,0,48,
+        46,1,0,0,0,49,51,5,13,0,0,50,49,1,0,0,0,51,54,1,0,0,0,52,50,1,0,
+        0,0,52,53,1,0,0,0,53,55,1,0,0,0,54,52,1,0,0,0,55,59,3,8,4,0,56,58,
+        5,13,0,0,57,56,1,0,0,0,58,61,1,0,0,0,59,57,1,0,0,0,59,60,1,0,0,0,
+        60,7,1,0,0,0,61,59,1,0,0,0,62,72,3,10,5,0,63,65,5,13,0,0,64,63,1,
+        0,0,0,65,68,1,0,0,0,66,64,1,0,0,0,66,67,1,0,0,0,67,69,1,0,0,0,68,
+        66,1,0,0,0,69,71,3,10,5,0,70,66,1,0,0,0,71,74,1,0,0,0,72,70,1,0,
+        0,0,72,73,1,0,0,0,73,9,1,0,0,0,74,72,1,0,0,0,75,76,7,1,0,0,76,11,
+        1,0,0,0,9,15,22,33,40,46,52,59,66,72
+    ]
+
+class CanadianAddressParser ( Parser ):
+
+    grammarFileName = "CanadianAddress.g4"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "'/'", "'-'", "'.'", "','", "'&'", "'('", 
+                     "')'" ]
+
+    symbolicNames = [ "<INVALID>", "POSTAL_CODE", "NUMBER", "WORD", "ALPHANUMERIC", 
+                      "SLASH", "HYPHEN", "DOT", "COMMA", "AMPERSAND", "LPAREN", 
+                      "RPAREN", "NL", "WS", "CATCHALL" ]
+
+    RULE_address = 0
+    RULE_addressBody = 1
+    RULE_lineSep = 2
+    RULE_addressLine = 3
+    RULE_lineContent = 4
+    RULE_lineToken = 5
+
+    ruleNames =  [ "address", "addressBody", "lineSep", "addressLine", "lineContent", 
+                   "lineToken" ]
+
+    EOF = Token.EOF
+    POSTAL_CODE=1
+    NUMBER=2
+    WORD=3
+    ALPHANUMERIC=4
+    SLASH=5
+    HYPHEN=6
+    DOT=7
+    COMMA=8
+    AMPERSAND=9
+    LPAREN=10
+    RPAREN=11
+    NL=12
+    WS=13
+    CATCHALL=14
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.13.2")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+
+    class AddressContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def addressBody(self):
+            return self.getTypedRuleContext(CanadianAddressParser.AddressBodyContext,0)
+
+
+        def EOF(self):
+            return self.getToken(CanadianAddressParser.EOF, 0)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.WS)
+            else:
+                return self.getToken(CanadianAddressParser.WS, i)
+
+        def NL(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.NL)
+            else:
+                return self.getToken(CanadianAddressParser.NL, i)
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_address
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAddress" ):
+                return visitor.visitAddress(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def address(self):
+
+        localctx = CanadianAddressParser.AddressContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_address)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 15
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 12
+                    _la = self._input.LA(1)
+                    if not(_la==12 or _la==13):
+                        self._errHandler.recoverInline(self)
+                    else:
+                        self._errHandler.reportMatch(self)
+                        self.consume() 
+                self.state = 17
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
+
+            self.state = 18
+            self.addressBody()
+            self.state = 22
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==12 or _la==13:
+                self.state = 19
+                _la = self._input.LA(1)
+                if not(_la==12 or _la==13):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self._errHandler.reportMatch(self)
+                    self.consume()
+                self.state = 24
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 25
+            self.match(CanadianAddressParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class AddressBodyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def addressLine(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CanadianAddressParser.AddressLineContext)
+            else:
+                return self.getTypedRuleContext(CanadianAddressParser.AddressLineContext,i)
+
+
+        def lineSep(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CanadianAddressParser.LineSepContext)
+            else:
+                return self.getTypedRuleContext(CanadianAddressParser.LineSepContext,i)
+
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_addressBody
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAddressBody" ):
+                return visitor.visitAddressBody(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def addressBody(self):
+
+        localctx = CanadianAddressParser.AddressBodyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_addressBody)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 27
+            self.addressLine()
+            self.state = 33
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 28
+                    self.lineSep()
+                    self.state = 29
+                    self.addressLine() 
+                self.state = 35
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class LineSepContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def NL(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.NL)
+            else:
+                return self.getToken(CanadianAddressParser.NL, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.WS)
+            else:
+                return self.getToken(CanadianAddressParser.WS, i)
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_lineSep
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLineSep" ):
+                return visitor.visitLineSep(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def lineSep(self):
+
+        localctx = CanadianAddressParser.LineSepContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_lineSep)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 36
+            self.match(CanadianAddressParser.NL)
+            self.state = 46
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 40
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    while _la==13:
+                        self.state = 37
+                        self.match(CanadianAddressParser.WS)
+                        self.state = 42
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+
+                    self.state = 43
+                    self.match(CanadianAddressParser.NL) 
+                self.state = 48
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class AddressLineContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def lineContent(self):
+            return self.getTypedRuleContext(CanadianAddressParser.LineContentContext,0)
+
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.WS)
+            else:
+                return self.getToken(CanadianAddressParser.WS, i)
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_addressLine
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAddressLine" ):
+                return visitor.visitAddressLine(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def addressLine(self):
+
+        localctx = CanadianAddressParser.AddressLineContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_addressLine)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 52
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==13:
+                self.state = 49
+                self.match(CanadianAddressParser.WS)
+                self.state = 54
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 55
+            self.lineContent()
+            self.state = 59
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 56
+                    self.match(CanadianAddressParser.WS) 
+                self.state = 61
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class LineContentContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def lineToken(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(CanadianAddressParser.LineTokenContext)
+            else:
+                return self.getTypedRuleContext(CanadianAddressParser.LineTokenContext,i)
+
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(CanadianAddressParser.WS)
+            else:
+                return self.getToken(CanadianAddressParser.WS, i)
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_lineContent
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLineContent" ):
+                return visitor.visitLineContent(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def lineContent(self):
+
+        localctx = CanadianAddressParser.LineContentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_lineContent)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 62
+            self.lineToken()
+            self.state = 72
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 66
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    while _la==13:
+                        self.state = 63
+                        self.match(CanadianAddressParser.WS)
+                        self.state = 68
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+
+                    self.state = 69
+                    self.lineToken() 
+                self.state = 74
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class LineTokenContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def WORD(self):
+            return self.getToken(CanadianAddressParser.WORD, 0)
+
+        def NUMBER(self):
+            return self.getToken(CanadianAddressParser.NUMBER, 0)
+
+        def POSTAL_CODE(self):
+            return self.getToken(CanadianAddressParser.POSTAL_CODE, 0)
+
+        def ALPHANUMERIC(self):
+            return self.getToken(CanadianAddressParser.ALPHANUMERIC, 0)
+
+        def HYPHEN(self):
+            return self.getToken(CanadianAddressParser.HYPHEN, 0)
+
+        def SLASH(self):
+            return self.getToken(CanadianAddressParser.SLASH, 0)
+
+        def DOT(self):
+            return self.getToken(CanadianAddressParser.DOT, 0)
+
+        def COMMA(self):
+            return self.getToken(CanadianAddressParser.COMMA, 0)
+
+        def AMPERSAND(self):
+            return self.getToken(CanadianAddressParser.AMPERSAND, 0)
+
+        def LPAREN(self):
+            return self.getToken(CanadianAddressParser.LPAREN, 0)
+
+        def RPAREN(self):
+            return self.getToken(CanadianAddressParser.RPAREN, 0)
+
+        def getRuleIndex(self):
+            return CanadianAddressParser.RULE_lineToken
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLineToken" ):
+                return visitor.visitLineToken(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def lineToken(self):
+
+        localctx = CanadianAddressParser.LineTokenContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_lineToken)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 75
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4094) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+
+
+

northpost_parser/generated/CanadianAddressVisitor.py

@@ -0,0 +1,43 @@
+# Generated from CanadianAddress.g4 by ANTLR 4.13.2
+from antlr4 import *
+if "." in __name__:
+    from .CanadianAddressParser import CanadianAddressParser
+else:
+    from CanadianAddressParser import CanadianAddressParser
+
+# This class defines a complete generic visitor for a parse tree produced by CanadianAddressParser.
+
+class CanadianAddressVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by CanadianAddressParser#address.
+    def visitAddress(self, ctx:CanadianAddressParser.AddressContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by CanadianAddressParser#addressBody.
+    def visitAddressBody(self, ctx:CanadianAddressParser.AddressBodyContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by CanadianAddressParser#lineSep.
+    def visitLineSep(self, ctx:CanadianAddressParser.LineSepContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by CanadianAddressParser#addressLine.
+    def visitAddressLine(self, ctx:CanadianAddressParser.AddressLineContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by CanadianAddressParser#lineContent.
+    def visitLineContent(self, ctx:CanadianAddressParser.LineContentContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by CanadianAddressParser#lineToken.
+    def visitLineToken(self, ctx:CanadianAddressParser.LineTokenContext):
+        return self.visitChildren(ctx)
+
+
+
+del CanadianAddressParser

northpost_parser/generated/__init__.py

@@ -0,0 +1 @@
+"""ANTLR4-generated Python lexer, parser, and visitor."""