Add files using upload-large-folder tool

py311/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py

@@ -0,0 +1,337 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarLexer.g4 by ANTLR 4.9.3
+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():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\36")
+        buf.write("\u01e7\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5")
+        buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13")
+        buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t")
+        buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26")
+        buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34")
+        buf.write("\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t")
+        buf.write("\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4")
+        buf.write("+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62")
+        buf.write("\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\3\2\3\2")
+        buf.write("\3\3\3\3\3\4\3\4\3\4\5\4y\n\4\3\4\7\4|\n\4\f\4\16\4\177")
+        buf.write("\13\4\5\4\u0081\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3")
+        buf.write("\7\7\7\u008c\n\7\f\7\16\7\u008f\13\7\3\7\3\7\3\b\7\b\u0094")
+        buf.write("\n\b\f\b\16\b\u0097\13\b\3\b\3\b\3\b\3\b\3\t\6\t\u009e")
+        buf.write("\n\t\r\t\16\t\u009f\3\n\6\n\u00a3\n\n\r\n\16\n\u00a4\3")
+        buf.write("\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u00b1\n")
+        buf.write("\f\3\f\3\f\3\r\3\r\5\r\u00b7\n\r\3\r\3\r\3\16\5\16\u00bc")
+        buf.write("\n\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20")
+        buf.write("\3\20\3\20\3\21\5\21\u00cb\n\21\3\21\3\21\5\21\u00cf\n")
+        buf.write("\21\3\22\3\22\5\22\u00d3\n\22\3\23\5\23\u00d6\n\23\3\23")
+        buf.write("\3\23\3\24\5\24\u00db\n\24\3\24\3\24\5\24\u00df\n\24\3")
+        buf.write("\25\3\25\3\25\3\25\5\25\u00e5\n\25\3\25\3\25\3\25\5\25")
+        buf.write("\u00ea\n\25\3\25\7\25\u00ed\n\25\f\25\16\25\u00f0\13\25")
+        buf.write("\5\25\u00f2\n\25\3\26\3\26\5\26\u00f6\n\26\3\26\3\26\5")
+        buf.write("\26\u00fa\n\26\3\26\3\26\5\26\u00fe\n\26\3\26\7\26\u0101")
+        buf.write("\n\26\f\26\16\26\u0104\13\26\3\27\5\27\u0107\n\27\3\27")
+        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u0111\n\27\3")
+        buf.write("\30\5\30\u0114\n\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\5\31\u0121\n\31\3\32\3\32\3\32\3")
+        buf.write("\32\3\32\3\33\3\33\3\34\3\34\5\34\u012c\n\34\3\34\3\34")
+        buf.write("\3\34\7\34\u0131\n\34\f\34\16\34\u0134\13\34\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35")
+        buf.write("\u014d\n\35\r\35\16\35\u014e\3\36\6\36\u0152\n\36\r\36")
+        buf.write("\16\36\u0153\3\37\3\37\5\37\u0158\n\37\3\37\3\37\3\37")
+        buf.write("\3 \5 \u015e\n \3 \3 \5 \u0162\n \3 \3 \3 \3!\5!\u0168")
+        buf.write("\n!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3$\3$\3$\3$\3%\3%")
+        buf.write("\3%\3%\3&\6&\u017d\n&\r&\16&\u017e\3\'\3\'\3\'\3\'\3\'")
+        buf.write("\3(\3(\3(\3(\3)\7)\u018b\n)\f)\16)\u018e\13)\3)\3)\3)")
+        buf.write("\3)\3*\3*\3*\3*\3+\7+\u0199\n+\f+\16+\u019c\13+\3+\3+")
+        buf.write("\3+\3+\3+\3,\6,\u01a4\n,\r,\16,\u01a5\3-\6-\u01a9\n-\r")
+        buf.write("-\16-\u01aa\3-\3-\3.\3.\3.\3.\3/\3/\3/\3/\3/\3\60\3\60")
+        buf.write("\3\60\3\60\3\60\3\61\7\61\u01be\n\61\f\61\16\61\u01c1")
+        buf.write("\13\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\7")
+        buf.write("\63\u01cc\n\63\f\63\16\63\u01cf\13\63\3\63\3\63\3\63\3")
+        buf.write("\63\3\63\3\64\6\64\u01d7\n\64\r\64\16\64\u01d8\3\64\3")
+        buf.write("\64\3\65\6\65\u01de\n\65\r\65\16\65\u01df\3\65\3\65\3")
+        buf.write("\66\3\66\3\66\3\66\2\2\67\7\2\t\2\13\2\r\2\17\2\21\3\23")
+        buf.write("\4\25\5\27\2\31\34\33\6\35\7\37\b!\t#\n%\13\'\f)\r+\16")
+        buf.write("-\2/\2\61\17\63\20\65\21\67\229\23;\24=\25?\26A\2C\2E")
+        buf.write("\27G\30I\35K\36M\2O\31Q\2S\32U\2W\2Y\2[\33]\2_\2a\2c\2")
+        buf.write("e\2g\2i\2k\2m\2o\2\7\2\3\4\5\6\32\4\2C\\c|\3\2\62;\3\2")
+        buf.write("\63;\3\2&&\4\2&&^^\4\2GGgg\4\2--//\4\2KKkk\4\2PPpp\4\2")
+        buf.write("HHhh\4\2CCcc\4\2VVvv\4\2TTtt\4\2WWww\4\2NNnn\4\2UUuu\b")
+        buf.write("\2&\',-/\61AB^^~~\4\2//aa\4\2\13\13\"\"\13\2\13\13\"\"")
+        buf.write("$$)+\60\60<<]_}}\177\177\4\2&&))\5\2&&))^^\4\2$$&&\5\2")
+        buf.write("$$&&^^\2\u0218\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
+        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\33\3\2\2\2\3")
+        buf.write("\35\3\2\2\2\3\37\3\2\2\2\3!\3\2\2\2\3#\3\2\2\2\3%\3\2")
+        buf.write("\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\3\61\3\2\2\2\3")
+        buf.write("\63\3\2\2\2\3\65\3\2\2\2\3\67\3\2\2\2\39\3\2\2\2\3;\3")
+        buf.write("\2\2\2\3=\3\2\2\2\3?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4E")
+        buf.write("\3\2\2\2\4G\3\2\2\2\4I\3\2\2\2\4K\3\2\2\2\4M\3\2\2\2\4")
+        buf.write("O\3\2\2\2\5Q\3\2\2\2\5S\3\2\2\2\5U\3\2\2\2\5W\3\2\2\2")
+        buf.write("\5Y\3\2\2\2\5[\3\2\2\2\5]\3\2\2\2\5_\3\2\2\2\6a\3\2\2")
+        buf.write("\2\6c\3\2\2\2\6e\3\2\2\2\6g\3\2\2\2\6i\3\2\2\2\6k\3\2")
+        buf.write("\2\2\6m\3\2\2\2\6o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13\u0080")
+        buf.write("\3\2\2\2\r\u0082\3\2\2\2\17\u0085\3\2\2\2\21\u008d\3\2")
+        buf.write("\2\2\23\u0095\3\2\2\2\25\u009d\3\2\2\2\27\u00a2\3\2\2")
+        buf.write("\2\31\u00a8\3\2\2\2\33\u00ac\3\2\2\2\35\u00b4\3\2\2\2")
+        buf.write("\37\u00bb\3\2\2\2!\u00c1\3\2\2\2#\u00c5\3\2\2\2%\u00ca")
+        buf.write("\3\2\2\2\'\u00d0\3\2\2\2)\u00d5\3\2\2\2+\u00da\3\2\2\2")
+        buf.write("-\u00f1\3\2\2\2/\u00f5\3\2\2\2\61\u0106\3\2\2\2\63\u0113")
+        buf.write("\3\2\2\2\65\u0120\3\2\2\2\67\u0122\3\2\2\29\u0127\3\2")
+        buf.write("\2\2;\u012b\3\2\2\2=\u014c\3\2\2\2?\u0151\3\2\2\2A\u0155")
+        buf.write("\3\2\2\2C\u015d\3\2\2\2E\u0167\3\2\2\2G\u016d\3\2\2\2")
+        buf.write("I\u016f\3\2\2\2K\u0173\3\2\2\2M\u0177\3\2\2\2O\u017c\3")
+        buf.write("\2\2\2Q\u0180\3\2\2\2S\u0185\3\2\2\2U\u018c\3\2\2\2W\u0193")
+        buf.write("\3\2\2\2Y\u019a\3\2\2\2[\u01a3\3\2\2\2]\u01a8\3\2\2\2")
+        buf.write("_\u01ae\3\2\2\2a\u01b2\3\2\2\2c\u01b7\3\2\2\2e\u01bf\3")
+        buf.write("\2\2\2g\u01c6\3\2\2\2i\u01cd\3\2\2\2k\u01d6\3\2\2\2m\u01dd")
+        buf.write("\3\2\2\2o\u01e3\3\2\2\2qr\t\2\2\2r\b\3\2\2\2st\t\3\2\2")
+        buf.write("t\n\3\2\2\2u\u0081\7\62\2\2v}\t\4\2\2wy\7a\2\2xw\3\2\2")
+        buf.write("\2xy\3\2\2\2yz\3\2\2\2z|\5\t\3\2{x\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("u\3\2\2\2\u0080v\3\2\2\2\u0081\f\3\2\2\2\u0082\u0083\7")
+        buf.write("^\2\2\u0083\u0084\7^\2\2\u0084\16\3\2\2\2\u0085\u0086")
+        buf.write("\5\33\f\2\u0086\u0087\3\2\2\2\u0087\u0088\b\6\2\2\u0088")
+        buf.write("\u0089\b\6\3\2\u0089\20\3\2\2\2\u008a\u008c\n\5\2\2\u008b")
+        buf.write("\u008a\3\2\2\2\u008c\u008f\3\2\2\2\u008d\u008b\3\2\2\2")
+        buf.write("\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u008d\3")
+        buf.write("\2\2\2\u0090\u0091\n\6\2\2\u0091\22\3\2\2\2\u0092\u0094")
+        buf.write("\5\r\5\2\u0093\u0092\3\2\2\2\u0094\u0097\3\2\2\2\u0095")
+        buf.write("\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2\2\2")
+        buf.write("\u0097\u0095\3\2\2\2\u0098\u0099\7^\2\2\u0099\u009a\7")
+        buf.write("&\2\2\u009a\u009b\7}\2\2\u009b\24\3\2\2\2\u009c\u009e")
+        buf.write("\5\r\5\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f")
+        buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\26\3\2\2\2\u00a1")
+        buf.write("\u00a3\7^\2\2\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2")
+        buf.write("\u00a4\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\3")
+        buf.write("\2\2\2\u00a6\u00a7\b\n\4\2\u00a7\30\3\2\2\2\u00a8\u00a9")
+        buf.write("\7&\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\b\13\4\2\u00ab")
+        buf.write("\32\3\2\2\2\u00ac\u00ad\7&\2\2\u00ad\u00ae\7}\2\2\u00ae")
+        buf.write("\u00b0\3\2\2\2\u00af\u00b1\5?\36\2\u00b0\u00af\3\2\2\2")
+        buf.write("\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\b")
+        buf.write("\f\3\2\u00b3\34\3\2\2\2\u00b4\u00b6\7}\2\2\u00b5\u00b7")
+        buf.write("\5?\36\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
+        buf.write("\u00b8\3\2\2\2\u00b8\u00b9\b\r\5\2\u00b9\36\3\2\2\2\u00ba")
+        buf.write("\u00bc\5?\36\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2")
+        buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\177\2\2\u00be\u00bf")
+        buf.write("\3\2\2\2\u00bf\u00c0\b\16\6\2\u00c0 \3\2\2\2\u00c1\u00c2")
+        buf.write("\7)\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c4\b\17\7\2\u00c4")
+        buf.write("\"\3\2\2\2\u00c5\u00c6\7$\2\2\u00c6\u00c7\3\2\2\2\u00c7")
+        buf.write("\u00c8\b\20\b\2\u00c8$\3\2\2\2\u00c9\u00cb\5?\36\2\u00ca")
+        buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2")
+        buf.write("\u00cc\u00ce\7.\2\2\u00cd\u00cf\5?\36\2\u00ce\u00cd\3")
+        buf.write("\2\2\2\u00ce\u00cf\3\2\2\2\u00cf&\3\2\2\2\u00d0\u00d2")
+        buf.write("\7]\2\2\u00d1\u00d3\5?\36\2\u00d2\u00d1\3\2\2\2\u00d2")
+        buf.write("\u00d3\3\2\2\2\u00d3(\3\2\2\2\u00d4\u00d6\5?\36\2\u00d5")
+        buf.write("\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d7\3\2\2\2")
+        buf.write("\u00d7\u00d8\7_\2\2\u00d8*\3\2\2\2\u00d9\u00db\5?\36\2")
+        buf.write("\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3")
+        buf.write("\2\2\2\u00dc\u00de\7<\2\2\u00dd\u00df\5?\36\2\u00de\u00dd")
+        buf.write("\3\2\2\2\u00de\u00df\3\2\2\2\u00df,\3\2\2\2\u00e0\u00e1")
+        buf.write("\5\13\4\2\u00e1\u00e2\7\60\2\2\u00e2\u00f2\3\2\2\2\u00e3")
+        buf.write("\u00e5\5\13\4\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5\3\2\2")
+        buf.write("\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\7\60\2\2\u00e7\u00ee")
+        buf.write("\5\t\3\2\u00e8\u00ea\7a\2\2\u00e9\u00e8\3\2\2\2\u00e9")
+        buf.write("\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ed\5\t\3\2")
+        buf.write("\u00ec\u00e9\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3")
+        buf.write("\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee")
+        buf.write("\3\2\2\2\u00f1\u00e0\3\2\2\2\u00f1\u00e4\3\2\2\2\u00f2")
+        buf.write(".\3\2\2\2\u00f3\u00f6\5\13\4\2\u00f4\u00f6\5-\25\2\u00f5")
+        buf.write("\u00f3\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2")
+        buf.write("\u00f7\u00f9\t\7\2\2\u00f8\u00fa\t\b\2\2\u00f9\u00f8\3")
+        buf.write("\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u0102")
+        buf.write("\5\t\3\2\u00fc\u00fe\7a\2\2\u00fd\u00fc\3\2\2\2\u00fd")
+        buf.write("\u00fe\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\5\t\3\2")
+        buf.write("\u0100\u00fd\3\2\2\2\u0101\u0104\3\2\2\2\u0102\u0100\3")
+        buf.write("\2\2\2\u0102\u0103\3\2\2\2\u0103\60\3\2\2\2\u0104\u0102")
+        buf.write("\3\2\2\2\u0105\u0107\t\b\2\2\u0106\u0105\3\2\2\2\u0106")
+        buf.write("\u0107\3\2\2\2\u0107\u0110\3\2\2\2\u0108\u0111\5-\25\2")
+        buf.write("\u0109\u0111\5/\26\2\u010a\u010b\t\t\2\2\u010b\u010c\t")
+        buf.write("\n\2\2\u010c\u0111\t\13\2\2\u010d\u010e\t\n\2\2\u010e")
+        buf.write("\u010f\t\f\2\2\u010f\u0111\t\n\2\2\u0110\u0108\3\2\2\2")
+        buf.write("\u0110\u0109\3\2\2\2\u0110\u010a\3\2\2\2\u0110\u010d\3")
+        buf.write("\2\2\2\u0111\62\3\2\2\2\u0112\u0114\t\b\2\2\u0113\u0112")
+        buf.write("\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2\2\2\u0115")
+        buf.write("\u0116\5\13\4\2\u0116\64\3\2\2\2\u0117\u0118\t\r\2\2\u0118")
+        buf.write("\u0119\t\16\2\2\u0119\u011a\t\17\2\2\u011a\u0121\t\7\2")
+        buf.write("\2\u011b\u011c\t\13\2\2\u011c\u011d\t\f\2\2\u011d\u011e")
+        buf.write("\t\20\2\2\u011e\u011f\t\21\2\2\u011f\u0121\t\7\2\2\u0120")
+        buf.write("\u0117\3\2\2\2\u0120\u011b\3\2\2\2\u0121\66\3\2\2\2\u0122")
+        buf.write("\u0123\t\n\2\2\u0123\u0124\t\17\2\2\u0124\u0125\t\20\2")
+        buf.write("\2\u0125\u0126\t\20\2\2\u01268\3\2\2\2\u0127\u0128\t\22")
+        buf.write("\2\2\u0128:\3\2\2\2\u0129\u012c\5\7\2\2\u012a\u012c\7")
+        buf.write("a\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u0132")
+        buf.write("\3\2\2\2\u012d\u0131\5\7\2\2\u012e\u0131\5\t\3\2\u012f")
+        buf.write("\u0131\t\23\2\2\u0130\u012d\3\2\2\2\u0130\u012e\3\2\2")
+        buf.write("\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130")
+        buf.write("\3\2\2\2\u0132\u0133\3\2\2\2\u0133<\3\2\2\2\u0134\u0132")
+        buf.write("\3\2\2\2\u0135\u014d\5\r\5\2\u0136\u0137\7^\2\2\u0137")
+        buf.write("\u014d\7*\2\2\u0138\u0139\7^\2\2\u0139\u014d\7+\2\2\u013a")
+        buf.write("\u013b\7^\2\2\u013b\u014d\7]\2\2\u013c\u013d\7^\2\2\u013d")
+        buf.write("\u014d\7_\2\2\u013e\u013f\7^\2\2\u013f\u014d\7}\2\2\u0140")
+        buf.write("\u0141\7^\2\2\u0141\u014d\7\177\2\2\u0142\u0143\7^\2\2")
+        buf.write("\u0143\u014d\7<\2\2\u0144\u0145\7^\2\2\u0145\u014d\7?")
+        buf.write("\2\2\u0146\u0147\7^\2\2\u0147\u014d\7.\2\2\u0148\u0149")
+        buf.write("\7^\2\2\u0149\u014d\7\"\2\2\u014a\u014b\7^\2\2\u014b\u014d")
+        buf.write("\7\13\2\2\u014c\u0135\3\2\2\2\u014c\u0136\3\2\2\2\u014c")
+        buf.write("\u0138\3\2\2\2\u014c\u013a\3\2\2\2\u014c\u013c\3\2\2\2")
+        buf.write("\u014c\u013e\3\2\2\2\u014c\u0140\3\2\2\2\u014c\u0142\3")
+        buf.write("\2\2\2\u014c\u0144\3\2\2\2\u014c\u0146\3\2\2\2\u014c\u0148")
+        buf.write("\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\3\2\2\2\u014e")
+        buf.write("\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f>\3\2\2\2\u0150")
+        buf.write("\u0152\t\24\2\2\u0151\u0150\3\2\2\2\u0152\u0153\3\2\2")
+        buf.write("\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154@\3\2")
+        buf.write("\2\2\u0155\u0157\5\33\f\2\u0156\u0158\5?\36\2\u0157\u0156")
+        buf.write("\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159")
+        buf.write("\u015a\b\37\2\2\u015a\u015b\b\37\3\2\u015bB\3\2\2\2\u015c")
+        buf.write("\u015e\5?\36\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2")
+        buf.write("\u015e\u015f\3\2\2\2\u015f\u0161\7<\2\2\u0160\u0162\5")
+        buf.write("?\36\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163")
+        buf.write("\3\2\2\2\u0163\u0164\b \t\2\u0164\u0165\b \n\2\u0165D")
+        buf.write("\3\2\2\2\u0166\u0168\5?\36\2\u0167\u0166\3\2\2\2\u0167")
+        buf.write("\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\7\177\2")
+        buf.write("\2\u016a\u016b\3\2\2\2\u016b\u016c\b!\6\2\u016cF\3\2\2")
+        buf.write("\2\u016d\u016e\7\60\2\2\u016eH\3\2\2\2\u016f\u0170\7]")
+        buf.write("\2\2\u0170\u0171\3\2\2\2\u0171\u0172\b#\13\2\u0172J\3")
+        buf.write("\2\2\2\u0173\u0174\7_\2\2\u0174\u0175\3\2\2\2\u0175\u0176")
+        buf.write("\b$\f\2\u0176L\3\2\2\2\u0177\u0178\5;\34\2\u0178\u0179")
+        buf.write("\3\2\2\2\u0179\u017a\b%\r\2\u017aN\3\2\2\2\u017b\u017d")
+        buf.write("\n\25\2\2\u017c\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e")
+        buf.write("\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017fP\3\2\2\2\u0180")
+        buf.write("\u0181\5\33\f\2\u0181\u0182\3\2\2\2\u0182\u0183\b\'\2")
+        buf.write("\2\u0183\u0184\b\'\3\2\u0184R\3\2\2\2\u0185\u0186\7)\2")
+        buf.write("\2\u0186\u0187\3\2\2\2\u0187\u0188\b(\6\2\u0188T\3\2\2")
+        buf.write("\2\u0189\u018b\n\26\2\2\u018a\u0189\3\2\2\2\u018b\u018e")
+        buf.write("\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d")
+        buf.write("\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0190\n\27\2")
+        buf.write("\2\u0190\u0191\3\2\2\2\u0191\u0192\b)\4\2\u0192V\3\2\2")
+        buf.write("\2\u0193\u0194\5\23\b\2\u0194\u0195\3\2\2\2\u0195\u0196")
+        buf.write("\b*\16\2\u0196X\3\2\2\2\u0197\u0199\5\r\5\2\u0198\u0197")
+        buf.write("\3\2\2\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a")
+        buf.write("\u019b\3\2\2\2\u019b\u019d\3\2\2\2\u019c\u019a\3\2\2\2")
+        buf.write("\u019d\u019e\7^\2\2\u019e\u019f\7)\2\2\u019f\u01a0\3\2")
+        buf.write("\2\2\u01a0\u01a1\b+\17\2\u01a1Z\3\2\2\2\u01a2\u01a4\5")
+        buf.write("\r\5\2\u01a3\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a3")
+        buf.write("\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\\\3\2\2\2\u01a7\u01a9")
+        buf.write("\7^\2\2\u01a8\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa")
+        buf.write("\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2")
+        buf.write("\u01ac\u01ad\b-\4\2\u01ad^\3\2\2\2\u01ae\u01af\7&\2\2")
+        buf.write("\u01af\u01b0\3\2\2\2\u01b0\u01b1\b.\4\2\u01b1`\3\2\2\2")
+        buf.write("\u01b2\u01b3\5\33\f\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5")
+        buf.write("\b/\2\2\u01b5\u01b6\b/\3\2\u01b6b\3\2\2\2\u01b7\u01b8")
+        buf.write("\7$\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\b\60\20\2\u01ba")
+        buf.write("\u01bb\b\60\6\2\u01bbd\3\2\2\2\u01bc\u01be\n\30\2\2\u01bd")
+        buf.write("\u01bc\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2")
+        buf.write("\u01bf\u01c0\3\2\2\2\u01c0\u01c2\3\2\2\2\u01c1\u01bf\3")
+        buf.write("\2\2\2\u01c2\u01c3\n\31\2\2\u01c3\u01c4\3\2\2\2\u01c4")
+        buf.write("\u01c5\b\61\4\2\u01c5f\3\2\2\2\u01c6\u01c7\5\23\b\2\u01c7")
+        buf.write("\u01c8\3\2\2\2\u01c8\u01c9\b\62\16\2\u01c9h\3\2\2\2\u01ca")
+        buf.write("\u01cc\5\r\5\2\u01cb\u01ca\3\2\2\2\u01cc\u01cf\3\2\2\2")
+        buf.write("\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0\3")
+        buf.write("\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\7^\2\2\u01d1\u01d2")
+        buf.write("\7$\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\b\63\17\2\u01d4")
+        buf.write("j\3\2\2\2\u01d5\u01d7\5\r\5\2\u01d6\u01d5\3\2\2\2\u01d7")
+        buf.write("\u01d8\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2")
+        buf.write("\u01d9\u01da\3\2\2\2\u01da\u01db\b\64\21\2\u01dbl\3\2")
+        buf.write("\2\2\u01dc\u01de\7^\2\2\u01dd\u01dc\3\2\2\2\u01de\u01df")
+        buf.write("\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0")
+        buf.write("\u01e1\3\2\2\2\u01e1\u01e2\b\65\4\2\u01e2n\3\2\2\2\u01e3")
+        buf.write("\u01e4\7&\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\b\66\4\2")
+        buf.write("\u01e6p\3\2\2\2\66\2\3\4\5\6x}\u0080\u008d\u0095\u009f")
+        buf.write("\u00a4\u00b0\u00b6\u00bb\u00ca\u00ce\u00d2\u00d5\u00da")
+        buf.write("\u00de\u00e4\u00e9\u00ee\u00f1\u00f5\u00f9\u00fd\u0102")
+        buf.write("\u0106\u0110\u0113\u0120\u012b\u0130\u0132\u014c\u014e")
+        buf.write("\u0153\u0157\u015d\u0161\u0167\u017e\u018c\u019a\u01a5")
+        buf.write("\u01aa\u01bf\u01cd\u01d8\u01df\22\t\6\2\7\4\2\t\3\2\7")
+        buf.write("\3\2\6\2\2\7\5\2\7\6\2\t\16\2\4\3\2\t\f\2\t\r\2\t\24\2")
+        buf.write("\t\4\2\t\25\2\t\32\2\t\33\2")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    VALUE_MODE = 1
+    INTERPOLATION_MODE = 2
+    QUOTED_SINGLE_MODE = 3
+    QUOTED_DOUBLE_MODE = 4
+
+    ANY_STR = 1
+    ESC_INTER = 2
+    TOP_ESC = 3
+    INTER_OPEN = 4
+    BRACE_OPEN = 5
+    BRACE_CLOSE = 6
+    QUOTE_OPEN_SINGLE = 7
+    QUOTE_OPEN_DOUBLE = 8
+    COMMA = 9
+    BRACKET_OPEN = 10
+    BRACKET_CLOSE = 11
+    COLON = 12
+    FLOAT = 13
+    INT = 14
+    BOOL = 15
+    NULL = 16
+    UNQUOTED_CHAR = 17
+    ID = 18
+    ESC = 19
+    WS = 20
+    INTER_CLOSE = 21
+    DOT = 22
+    INTER_KEY = 23
+    MATCHING_QUOTE_CLOSE = 24
+    QUOTED_ESC = 25
+    DOLLAR = 26
+    INTER_BRACKET_OPEN = 27
+    INTER_BRACKET_CLOSE = 28
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE", "VALUE_MODE", "INTERPOLATION_MODE", "QUOTED_SINGLE_MODE", 
+                  "QUOTED_DOUBLE_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'.'", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", "BRACE_OPEN", 
+            "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", "QUOTE_OPEN_DOUBLE", "COMMA", 
+            "BRACKET_OPEN", "BRACKET_CLOSE", "COLON", "FLOAT", "INT", "BOOL", 
+            "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "INTER_CLOSE", "DOT", 
+            "INTER_KEY", "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", 
+            "INTER_BRACKET_OPEN", "INTER_BRACKET_CLOSE" ]
+
+    ruleNames = [ "CHAR", "DIGIT", "INT_UNSIGNED", "ESC_BACKSLASH", "TOP_INTER_OPEN", 
+                  "ANY_STR", "ESC_INTER", "TOP_ESC", "BACKSLASHES", "DOLLAR", 
+                  "INTER_OPEN", "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                  "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                  "COLON", "POINT_FLOAT", "EXPONENT_FLOAT", "FLOAT", "INT", 
+                  "BOOL", "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "NESTED_INTER_OPEN", 
+                  "INTER_COLON", "INTER_CLOSE", "DOT", "INTER_BRACKET_OPEN", 
+                  "INTER_BRACKET_CLOSE", "INTER_ID", "INTER_KEY", "QSINGLE_INTER_OPEN", 
+                  "MATCHING_QUOTE_CLOSE", "QSINGLE_STR", "QSINGLE_ESC_INTER", 
+                  "QSINGLE_ESC_QUOTE", "QUOTED_ESC", "QSINGLE_BACKSLASHES", 
+                  "QSINGLE_DOLLAR", "QDOUBLE_INTER_OPEN", "QDOUBLE_CLOSE", 
+                  "QDOUBLE_STR", "QDOUBLE_ESC_INTER", "QDOUBLE_ESC_QUOTE", 
+                  "QDOUBLE_ESC", "QDOUBLE_BACKSLASHES", "QDOUBLE_DOLLAR" ]
+
+    grammarFileName = "OmegaConfGrammarLexer.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

py311/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py

@@ -0,0 +1,1595 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+# 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():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\36")
+        buf.write("\u00b7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
+        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3\2\3\3\3")
+        buf.write("\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\6\4/\n\4\r\4\16\4\60\3")
+        buf.write("\5\3\5\3\5\3\5\5\5\67\n\5\3\6\3\6\5\6;\n\6\3\6\3\6\3\7")
+        buf.write("\3\7\3\7\3\7\7\7C\n\7\f\7\16\7F\13\7\5\7H\n\7\3\7\3\7")
+        buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\3\t\5\tS\n\t\7\tU\n\t\f\t\16")
+        buf.write("\tX\13\t\3\t\3\t\5\t\\\n\t\6\t^\n\t\r\t\16\t_\5\tb\n\t")
+        buf.write("\3\n\3\n\5\nf\n\n\3\13\3\13\7\13j\n\13\f\13\16\13m\13")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\5\13t\n\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\7\13|\n\13\f\13\16\13\177\13\13\3\13\3")
+        buf.write("\13\3\f\3\f\3\f\3\f\5\f\u0087\n\f\3\f\3\f\3\r\3\r\3\r")
+        buf.write("\5\r\u008e\n\r\3\16\3\16\5\16\u0092\n\16\3\16\3\16\3\16")
+        buf.write("\5\16\u0097\n\16\7\16\u0099\n\16\f\16\16\16\u009c\13\16")
+        buf.write("\3\17\3\17\5\17\u00a0\n\17\3\17\3\17\3\20\3\20\3\20\3")
+        buf.write("\20\3\20\3\20\3\20\3\20\3\20\3\20\6\20\u00ae\n\20\r\20")
+        buf.write("\16\20\u00af\3\21\6\21\u00b3\n\21\r\21\16\21\u00b4\3\21")
+        buf.write("\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \2\4\3")
+        buf.write("\2\t\n\3\2\17\26\2\u00ce\2\"\3\2\2\2\4%\3\2\2\2\6.\3\2")
+        buf.write("\2\2\b\66\3\2\2\2\n8\3\2\2\2\f>\3\2\2\2\16K\3\2\2\2\20")
+        buf.write("a\3\2\2\2\22e\3\2\2\2\24g\3\2\2\2\26\u0082\3\2\2\2\30")
+        buf.write("\u008d\3\2\2\2\32\u0091\3\2\2\2\34\u009d\3\2\2\2\36\u00ad")
+        buf.write("\3\2\2\2 \u00b2\3\2\2\2\"#\5\6\4\2#$\7\2\2\3$\3\3\2\2")
+        buf.write("\2%&\5\b\5\2&\'\7\2\2\3\'\5\3\2\2\2(/\5\22\n\2)/\7\3\2")
+        buf.write("\2*/\7\25\2\2+/\7\4\2\2,/\7\5\2\2-/\7\33\2\2.(\3\2\2\2")
+        buf.write(".)\3\2\2\2.*\3\2\2\2.+\3\2\2\2.,\3\2\2\2.-\3\2\2\2/\60")
+        buf.write("\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\7\3\2\2\2\62\67")
+        buf.write("\5\36\20\2\63\67\5\34\17\2\64\67\5\n\6\2\65\67\5\f\7\2")
+        buf.write("\66\62\3\2\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2")
+        buf.write("\2\67\t\3\2\2\28:\7\f\2\29;\5\20\t\2:9\3\2\2\2:;\3\2\2")
+        buf.write("\2;<\3\2\2\2<=\7\r\2\2=\13\3\2\2\2>G\7\7\2\2?D\5\16\b")
+        buf.write("\2@A\7\13\2\2AC\5\16\b\2B@\3\2\2\2CF\3\2\2\2DB\3\2\2\2")
+        buf.write("DE\3\2\2\2EH\3\2\2\2FD\3\2\2\2G?\3\2\2\2GH\3\2\2\2HI\3")
+        buf.write("\2\2\2IJ\7\b\2\2J\r\3\2\2\2KL\5 \21\2LM\7\16\2\2MN\5\b")
+        buf.write("\5\2N\17\3\2\2\2OV\5\b\5\2PR\7\13\2\2QS\5\b\5\2RQ\3\2")
+        buf.write("\2\2RS\3\2\2\2SU\3\2\2\2TP\3\2\2\2UX\3\2\2\2VT\3\2\2\2")
+        buf.write("VW\3\2\2\2Wb\3\2\2\2XV\3\2\2\2Y[\7\13\2\2Z\\\5\b\5\2[")
+        buf.write("Z\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2]Y\3\2\2\2^_\3\2\2\2_]")
+        buf.write("\3\2\2\2_`\3\2\2\2`b\3\2\2\2aO\3\2\2\2a]\3\2\2\2b\21\3")
+        buf.write("\2\2\2cf\5\24\13\2df\5\26\f\2ec\3\2\2\2ed\3\2\2\2f\23")
+        buf.write("\3\2\2\2gk\7\6\2\2hj\7\30\2\2ih\3\2\2\2jm\3\2\2\2ki\3")
+        buf.write("\2\2\2kl\3\2\2\2ls\3\2\2\2mk\3\2\2\2nt\5\30\r\2op\7\f")
+        buf.write("\2\2pq\5\30\r\2qr\7\r\2\2rt\3\2\2\2sn\3\2\2\2so\3\2\2")
+        buf.write("\2t}\3\2\2\2uv\7\30\2\2v|\5\30\r\2wx\7\f\2\2xy\5\30\r")
+        buf.write("\2yz\7\r\2\2z|\3\2\2\2{u\3\2\2\2{w\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("\u0081\7\27\2\2\u0081\25\3\2\2\2\u0082\u0083\7\6\2\2\u0083")
+        buf.write("\u0084\5\32\16\2\u0084\u0086\7\16\2\2\u0085\u0087\5\20")
+        buf.write("\t\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088")
+        buf.write("\3\2\2\2\u0088\u0089\7\b\2\2\u0089\27\3\2\2\2\u008a\u008e")
+        buf.write("\5\22\n\2\u008b\u008e\7\24\2\2\u008c\u008e\7\31\2\2\u008d")
+        buf.write("\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2")
+        buf.write("\u008e\31\3\2\2\2\u008f\u0092\5\22\n\2\u0090\u0092\7\24")
+        buf.write("\2\2\u0091\u008f\3\2\2\2\u0091\u0090\3\2\2\2\u0092\u009a")
+        buf.write("\3\2\2\2\u0093\u0096\7\30\2\2\u0094\u0097\5\22\n\2\u0095")
+        buf.write("\u0097\7\24\2\2\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2")
+        buf.write("\2\u0097\u0099\3\2\2\2\u0098\u0093\3\2\2\2\u0099\u009c")
+        buf.write("\3\2\2\2\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b")
+        buf.write("\33\3\2\2\2\u009c\u009a\3\2\2\2\u009d\u009f\t\2\2\2\u009e")
+        buf.write("\u00a0\5\6\4\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2\2")
+        buf.write("\u00a0\u00a1\3\2\2\2\u00a1\u00a2\7\32\2\2\u00a2\35\3\2")
+        buf.write("\2\2\u00a3\u00ae\7\24\2\2\u00a4\u00ae\7\22\2\2\u00a5\u00ae")
+        buf.write("\7\20\2\2\u00a6\u00ae\7\17\2\2\u00a7\u00ae\7\21\2\2\u00a8")
+        buf.write("\u00ae\7\23\2\2\u00a9\u00ae\7\16\2\2\u00aa\u00ae\7\25")
+        buf.write("\2\2\u00ab\u00ae\7\26\2\2\u00ac\u00ae\5\22\n\2\u00ad\u00a3")
+        buf.write("\3\2\2\2\u00ad\u00a4\3\2\2\2\u00ad\u00a5\3\2\2\2\u00ad")
+        buf.write("\u00a6\3\2\2\2\u00ad\u00a7\3\2\2\2\u00ad\u00a8\3\2\2\2")
+        buf.write("\u00ad\u00a9\3\2\2\2\u00ad\u00aa\3\2\2\2\u00ad\u00ab\3")
+        buf.write("\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad")
+        buf.write("\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\37\3\2\2\2\u00b1\u00b3")
+        buf.write("\t\3\2\2\u00b2\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4")
+        buf.write("\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5!\3\2\2\2\33.")
+        buf.write("\60\66:DGRV[_aeks{}\u0086\u008d\u0091\u0096\u009a\u009f")
+        buf.write("\u00ad\u00af\u00b4")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarParser ( Parser ):
+
+    grammarFileName = "OmegaConfGrammarParser.g4"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'.'", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>", "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", 
+                      "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                      "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                      "COLON", "FLOAT", "INT", "BOOL", "NULL", "UNQUOTED_CHAR", 
+                      "ID", "ESC", "WS", "INTER_CLOSE", "DOT", "INTER_KEY", 
+                      "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", "INTER_BRACKET_OPEN", 
+                      "INTER_BRACKET_CLOSE" ]
+
+    RULE_configValue = 0
+    RULE_singleElement = 1
+    RULE_text = 2
+    RULE_element = 3
+    RULE_listContainer = 4
+    RULE_dictContainer = 5
+    RULE_dictKeyValuePair = 6
+    RULE_sequence = 7
+    RULE_interpolation = 8
+    RULE_interpolationNode = 9
+    RULE_interpolationResolver = 10
+    RULE_configKey = 11
+    RULE_resolverName = 12
+    RULE_quotedValue = 13
+    RULE_primitive = 14
+    RULE_dictKey = 15
+
+    ruleNames =  [ "configValue", "singleElement", "text", "element", "listContainer", 
+                   "dictContainer", "dictKeyValuePair", "sequence", "interpolation", 
+                   "interpolationNode", "interpolationResolver", "configKey", 
+                   "resolverName", "quotedValue", "primitive", "dictKey" ]
+
+    EOF = Token.EOF
+    ANY_STR=1
+    ESC_INTER=2
+    TOP_ESC=3
+    INTER_OPEN=4
+    BRACE_OPEN=5
+    BRACE_CLOSE=6
+    QUOTE_OPEN_SINGLE=7
+    QUOTE_OPEN_DOUBLE=8
+    COMMA=9
+    BRACKET_OPEN=10
+    BRACKET_CLOSE=11
+    COLON=12
+    FLOAT=13
+    INT=14
+    BOOL=15
+    NULL=16
+    UNQUOTED_CHAR=17
+    ID=18
+    ESC=19
+    WS=20
+    INTER_CLOSE=21
+    DOT=22
+    INTER_KEY=23
+    MATCHING_QUOTE_CLOSE=24
+    QUOTED_ESC=25
+    DOLLAR=26
+    INTER_BRACKET_OPEN=27
+    INTER_BRACKET_CLOSE=28
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+
+    class ConfigValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigValue" ):
+                listener.enterConfigValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigValue" ):
+                listener.exitConfigValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigValue" ):
+                return visitor.visitConfigValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configValue(self):
+
+        localctx = OmegaConfGrammarParser.ConfigValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_configValue)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 32
+            self.text()
+            self.state = 33
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SingleElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_singleElement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSingleElement" ):
+                listener.enterSingleElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSingleElement" ):
+                listener.exitSingleElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSingleElement" ):
+                return visitor.visitSingleElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def singleElement(self):
+
+        localctx = OmegaConfGrammarParser.SingleElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_singleElement)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 35
+            self.element()
+            self.state = 36
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class TextContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ANY_STR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ANY_STR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ANY_STR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def ESC_INTER(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC_INTER)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC_INTER, i)
+
+        def TOP_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.TOP_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.TOP_ESC, i)
+
+        def QUOTED_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.QUOTED_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.QUOTED_ESC, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_text
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterText" ):
+                listener.enterText(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitText" ):
+                listener.exitText(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitText" ):
+                return visitor.visitText(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def text(self):
+
+        localctx = OmegaConfGrammarParser.TextContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_text)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 44 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 44
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 38
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ANY_STR]:
+                    self.state = 39
+                    self.match(OmegaConfGrammarParser.ANY_STR)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 40
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC_INTER]:
+                    self.state = 41
+                    self.match(OmegaConfGrammarParser.ESC_INTER)
+                    pass
+                elif token in [OmegaConfGrammarParser.TOP_ESC]:
+                    self.state = 42
+                    self.match(OmegaConfGrammarParser.TOP_ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.QUOTED_ESC]:
+                    self.state = 43
+                    self.match(OmegaConfGrammarParser.QUOTED_ESC)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 46 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def primitive(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.PrimitiveContext,0)
+
+
+        def quotedValue(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.QuotedValueContext,0)
+
+
+        def listContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ListContainerContext,0)
+
+
+        def dictContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictContainerContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_element
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterElement" ):
+                listener.enterElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitElement" ):
+                listener.exitElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitElement" ):
+                return visitor.visitElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def element(self):
+
+        localctx = OmegaConfGrammarParser.ElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_element)
+        try:
+            self.state = 52
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 48
+                self.primitive()
+                pass
+            elif token in [OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 49
+                self.quotedValue()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 50
+                self.listContainer()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACE_OPEN]:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 51
+                self.dictContainer()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ListContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACKET_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, 0)
+
+        def BRACKET_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_listContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterListContainer" ):
+                listener.enterListContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitListContainer" ):
+                listener.exitListContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitListContainer" ):
+                return visitor.visitListContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def listContainer(self):
+
+        localctx = OmegaConfGrammarParser.ListContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_listContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 54
+            self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+            self.state = 56
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 55
+                self.sequence()
+
+
+            self.state = 58
+            self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACE_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_OPEN, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def dictKeyValuePair(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.DictKeyValuePairContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyValuePairContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictContainer" ):
+                listener.enterDictContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictContainer" ):
+                listener.exitDictContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictContainer" ):
+                return visitor.visitDictContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictContainer(self):
+
+        localctx = OmegaConfGrammarParser.DictContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_dictContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 60
+            self.match(OmegaConfGrammarParser.BRACE_OPEN)
+            self.state = 69
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 61
+                self.dictKeyValuePair()
+                self.state = 66
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 62
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 63
+                    self.dictKeyValuePair()
+                    self.state = 68
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 71
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyValuePairContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def dictKey(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKeyValuePair
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKeyValuePair" ):
+                listener.enterDictKeyValuePair(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKeyValuePair" ):
+                listener.exitDictKeyValuePair(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKeyValuePair" ):
+                return visitor.visitDictKeyValuePair(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKeyValuePair(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyValuePairContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_dictKeyValuePair)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 73
+            self.dictKey()
+            self.state = 74
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 75
+            self.element()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SequenceContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ElementContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_sequence
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSequence" ):
+                listener.enterSequence(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSequence" ):
+                listener.exitSequence(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSequence" ):
+                return visitor.visitSequence(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def sequence(self):
+
+        localctx = OmegaConfGrammarParser.SequenceContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 14, self.RULE_sequence)
+        self._la = 0 # Token type
+        try:
+            self.state = 95
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.BRACE_OPEN, OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, OmegaConfGrammarParser.BRACKET_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 77
+                self.element()
+                self.state = 84
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 78
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 80
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 79
+                        self.element()
+
+
+                    self.state = 86
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                pass
+            elif token in [OmegaConfGrammarParser.COMMA]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 91 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 87
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 89
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 88
+                        self.element()
+
+
+                    self.state = 93 
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==OmegaConfGrammarParser.COMMA):
+                        break
+
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolationNode(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationNodeContext,0)
+
+
+        def interpolationResolver(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationResolverContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolation
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolation" ):
+                listener.enterInterpolation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolation" ):
+                listener.exitInterpolation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolation" ):
+                return visitor.visitInterpolation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolation(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_interpolation)
+        try:
+            self.state = 99
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 97
+                self.interpolationNode()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 98
+                self.interpolationResolver()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationNodeContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def INTER_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_CLOSE, 0)
+
+        def configKey(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ConfigKeyContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ConfigKeyContext,i)
+
+
+        def BRACKET_OPEN(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_OPEN)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, i)
+
+        def BRACKET_CLOSE(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_CLOSE)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationNode
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationNode" ):
+                listener.enterInterpolationNode(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationNode" ):
+                listener.exitInterpolationNode(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationNode" ):
+                return visitor.visitInterpolationNode(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationNode(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationNodeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 18, self.RULE_interpolationNode)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 101
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 105
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 102
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 107
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 113
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.INTER_KEY]:
+                self.state = 108
+                self.configKey()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.state = 109
+                self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                self.state = 110
+                self.configKey()
+                self.state = 111
+                self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 123
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.BRACKET_OPEN or _la==OmegaConfGrammarParser.DOT:
+                self.state = 121
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.DOT]:
+                    self.state = 115
+                    self.match(OmegaConfGrammarParser.DOT)
+                    self.state = 116
+                    self.configKey()
+                    pass
+                elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                    self.state = 117
+                    self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                    self.state = 118
+                    self.configKey()
+                    self.state = 119
+                    self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 125
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 126
+            self.match(OmegaConfGrammarParser.INTER_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationResolverContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def resolverName(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ResolverNameContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationResolver
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationResolver" ):
+                listener.enterInterpolationResolver(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationResolver" ):
+                listener.exitInterpolationResolver(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationResolver" ):
+                return visitor.visitInterpolationResolver(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationResolver(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationResolverContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 20, self.RULE_interpolationResolver)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 128
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 129
+            self.resolverName()
+            self.state = 130
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 132
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 131
+                self.sequence()
+
+
+            self.state = 134
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ConfigKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,0)
+
+
+        def ID(self):
+            return self.getToken(OmegaConfGrammarParser.ID, 0)
+
+        def INTER_KEY(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_KEY, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigKey" ):
+                listener.enterConfigKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigKey" ):
+                listener.exitConfigKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigKey" ):
+                return visitor.visitConfigKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configKey(self):
+
+        localctx = OmegaConfGrammarParser.ConfigKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_configKey)
+        try:
+            self.state = 139
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 136
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 137
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            elif token in [OmegaConfGrammarParser.INTER_KEY]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 138
+                self.match(OmegaConfGrammarParser.INTER_KEY)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ResolverNameContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_resolverName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterResolverName" ):
+                listener.enterResolverName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitResolverName" ):
+                listener.exitResolverName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitResolverName" ):
+                return visitor.visitResolverName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def resolverName(self):
+
+        localctx = OmegaConfGrammarParser.ResolverNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_resolverName)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 143
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.state = 141
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.state = 142
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 152
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 145
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 148
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 146
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ID]:
+                    self.state = 147
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 154
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class QuotedValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def MATCHING_QUOTE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE, 0)
+
+        def QUOTE_OPEN_SINGLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, 0)
+
+        def QUOTE_OPEN_DOUBLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, 0)
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_quotedValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuotedValue" ):
+                listener.enterQuotedValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuotedValue" ):
+                listener.exitQuotedValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitQuotedValue" ):
+                return visitor.visitQuotedValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def quotedValue(self):
+
+        localctx = OmegaConfGrammarParser.QuotedValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_quotedValue)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 155
+            _la = self._input.LA(1)
+            if not(_la==OmegaConfGrammarParser.QUOTE_OPEN_SINGLE or _la==OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+            self.state = 157
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0):
+                self.state = 156
+                self.text()
+
+
+            self.state = 159
+            self.match(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class PrimitiveContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def COLON(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COLON)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COLON, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_primitive
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimitive" ):
+                listener.enterPrimitive(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimitive" ):
+                listener.exitPrimitive(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimitive" ):
+                return visitor.visitPrimitive(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def primitive(self):
+
+        localctx = OmegaConfGrammarParser.PrimitiveContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 28, self.RULE_primitive)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 171 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 171
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.ID]:
+                    self.state = 161
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                elif token in [OmegaConfGrammarParser.NULL]:
+                    self.state = 162
+                    self.match(OmegaConfGrammarParser.NULL)
+                    pass
+                elif token in [OmegaConfGrammarParser.INT]:
+                    self.state = 163
+                    self.match(OmegaConfGrammarParser.INT)
+                    pass
+                elif token in [OmegaConfGrammarParser.FLOAT]:
+                    self.state = 164
+                    self.match(OmegaConfGrammarParser.FLOAT)
+                    pass
+                elif token in [OmegaConfGrammarParser.BOOL]:
+                    self.state = 165
+                    self.match(OmegaConfGrammarParser.BOOL)
+                    pass
+                elif token in [OmegaConfGrammarParser.UNQUOTED_CHAR]:
+                    self.state = 166
+                    self.match(OmegaConfGrammarParser.UNQUOTED_CHAR)
+                    pass
+                elif token in [OmegaConfGrammarParser.COLON]:
+                    self.state = 167
+                    self.match(OmegaConfGrammarParser.COLON)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 168
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.WS]:
+                    self.state = 169
+                    self.match(OmegaConfGrammarParser.WS)
+                    pass
+                elif token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 170
+                    self.interpolation()
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 173 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKey" ):
+                listener.enterDictKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKey" ):
+                listener.exitDictKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKey" ):
+                return visitor.visitDictKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKey(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 30, self.RULE_dictKey)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 176 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 175
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self._errHandler.reportMatch(self)
+                    self.consume()
+                self.state = 178 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+
+
+

py311/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py

@@ -0,0 +1,156 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete listener for a parse tree produced by OmegaConfGrammarParser.
+class OmegaConfGrammarParserListener(ParseTreeListener):
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configValue.
+    def enterConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def exitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def enterSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def exitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#text.
+    def enterText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#text.
+    def exitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#element.
+    def enterElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#element.
+    def exitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def enterListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def exitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def enterDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def exitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def enterDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def exitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#sequence.
+    def enterSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def exitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def enterInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def exitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def enterInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def exitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def enterInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def exitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configKey.
+    def enterConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def exitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def enterResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def exitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def enterQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def exitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#primitive.
+    def enterPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def exitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def enterDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def exitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+
+
+del OmegaConfGrammarParser

py311/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py

@@ -0,0 +1,93 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete generic visitor for a parse tree produced by OmegaConfGrammarParser.
+
+class OmegaConfGrammarParserVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def visitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def visitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#text.
+    def visitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#element.
+    def visitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def visitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def visitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def visitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def visitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def visitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def visitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def visitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def visitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def visitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def visitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def visitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def visitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        return self.visitChildren(ctx)
+
+
+
+del OmegaConfGrammarParser

py311/lib/python3.11/site-packages/omegaconf/resolvers/oc/__init__.py

@@ -0,0 +1,113 @@
+import os
+import string
+import warnings
+from typing import Any, Optional
+
+from omegaconf import Container, Node
+from omegaconf._utils import _DEFAULT_MARKER_, _get_value
+from omegaconf.basecontainer import BaseContainer
+from omegaconf.errors import ConfigKeyError
+from omegaconf.grammar_parser import parse
+from omegaconf.resolvers.oc import dict
+
+
+def create(obj: Any, _parent_: Container) -> Any:
+    """Create a config object from `obj`, similar to `OmegaConf.create`"""
+    from omegaconf import OmegaConf
+
+    assert isinstance(_parent_, BaseContainer)
+    return OmegaConf.create(obj, parent=_parent_)
+
+
+def env(key: str, default: Any = _DEFAULT_MARKER_) -> Optional[str]:
+    """
+    :param key: Environment variable key
+    :param default: Optional default value to use in case the key environment variable is not set.
+                    If default is not a string, it is converted with str(default).
+                    None default is returned as is.
+    :return: The environment variable 'key'. If the environment variable is not set and a default is
+            provided, the default is used. If used, the default is converted to a string with str(default).
+            If the default is None, None is returned (without a string conversion).
+    """
+    try:
+        return os.environ[key]
+    except KeyError:
+        if default is not _DEFAULT_MARKER_:
+            return str(default) if default is not None else None
+        else:
+            raise KeyError(f"Environment variable '{key}' not found")
+
+
+def decode(expr: Optional[str], _parent_: Container, _node_: Node) -> Any:
+    """
+    Parse and evaluate `expr` according to the `singleElement` rule of the grammar.
+
+    If `expr` is `None`, then return `None`.
+    """
+    if expr is None:
+        return None
+
+    if not isinstance(expr, str):
+        raise TypeError(
+            f"`oc.decode` can only take strings or None as input, "
+            f"but `{expr}` is of type {type(expr).__name__}"
+        )
+
+    parse_tree = parse(expr, parser_rule="singleElement", lexer_mode="VALUE_MODE")
+    val = _parent_.resolve_parse_tree(parse_tree, node=_node_)
+    return _get_value(val)
+
+
+def deprecated(
+    key: str,
+    message: str = "'$OLD_KEY' is deprecated. Change your code and config to use '$NEW_KEY'",
+    *,
+    _parent_: Container,
+    _node_: Node,
+) -> Any:
+    from omegaconf._impl import select_node
+
+    if not isinstance(key, str):
+        raise TypeError(
+            f"oc.deprecated: interpolation key type is not a string ({type(key).__name__})"
+        )
+
+    if not isinstance(message, str):
+        raise TypeError(
+            f"oc.deprecated: interpolation message type is not a string ({type(message).__name__})"
+        )
+
+    full_key = _node_._get_full_key(key=None)
+    target_node = select_node(_parent_, key, absolute_key=True)
+    if target_node is None:
+        raise ConfigKeyError(
+            f"In oc.deprecated resolver at '{full_key}': Key not found: '{key}'"
+        )
+    new_key = target_node._get_full_key(key=None)
+    msg = string.Template(message).safe_substitute(
+        OLD_KEY=full_key,
+        NEW_KEY=new_key,
+    )
+    warnings.warn(category=UserWarning, message=msg)
+    return target_node
+
+
+def select(
+    key: str,
+    default: Any = _DEFAULT_MARKER_,
+    *,
+    _parent_: Container,
+) -> Any:
+    from omegaconf._impl import select_value
+
+    return select_value(cfg=_parent_, key=key, absolute_key=True, default=default)
+
+
+__all__ = [
+    "create",
+    "decode",
+    "deprecated",
+    "dict",
+    "env",
+    "select",
+]

py311/lib/python3.11/site-packages/omegaconf/resolvers/oc/dict.py

@@ -0,0 +1,83 @@
+from typing import Any, List
+
+from omegaconf import AnyNode, Container, DictConfig, ListConfig
+from omegaconf._utils import Marker
+from omegaconf.basecontainer import BaseContainer
+from omegaconf.errors import ConfigKeyError
+
+_DEFAULT_SELECT_MARKER_: Any = Marker("_DEFAULT_SELECT_MARKER_")
+
+
+def keys(
+    key: str,
+    _parent_: Container,
+) -> ListConfig:
+    from omegaconf import OmegaConf
+
+    assert isinstance(_parent_, BaseContainer)
+
+    in_dict = _get_and_validate_dict_input(
+        key, parent=_parent_, resolver_name="oc.dict.keys"
+    )
+
+    ret = OmegaConf.create(list(in_dict.keys()), parent=_parent_)
+    assert isinstance(ret, ListConfig)
+    return ret
+
+
+def values(key: str, _root_: BaseContainer, _parent_: Container) -> ListConfig:
+    assert isinstance(_parent_, BaseContainer)
+    in_dict = _get_and_validate_dict_input(
+        key, parent=_parent_, resolver_name="oc.dict.values"
+    )
+
+    content = in_dict._content
+    assert isinstance(content, dict)
+
+    ret = ListConfig([])
+    if key.startswith("."):
+        key = f".{key}"  # extra dot to compensate for extra level of nesting within ret ListConfig
+    for k in content:
+        ref_node = AnyNode(f"${{{key}.{k!s}}}")
+        ret.append(ref_node)
+
+    # Finalize result by setting proper type and parent.
+    element_type: Any = in_dict._metadata.element_type
+    ret._metadata.element_type = element_type
+    ret._metadata.ref_type = List[element_type]
+    ret._set_parent(_parent_)
+
+    return ret
+
+
+def _get_and_validate_dict_input(
+    key: str,
+    parent: BaseContainer,
+    resolver_name: str,
+) -> DictConfig:
+    from omegaconf._impl import select_value
+
+    if not isinstance(key, str):
+        raise TypeError(
+            f"`{resolver_name}` requires a string as input, but obtained `{key}` "
+            f"of type: {type(key).__name__}"
+        )
+
+    in_dict = select_value(
+        parent,
+        key,
+        throw_on_missing=True,
+        absolute_key=True,
+        default=_DEFAULT_SELECT_MARKER_,
+    )
+
+    if in_dict is _DEFAULT_SELECT_MARKER_:
+        raise ConfigKeyError(f"Key not found: '{key}'")
+
+    if not isinstance(in_dict, DictConfig):
+        raise TypeError(
+            f"`{resolver_name}` cannot be applied to objects of type: "
+            f"{type(in_dict).__name__}"
+        )
+
+    return in_dict

py311/lib/python3.11/site-packages/openai/_extras/__init__.py

@@ -0,0 +1,3 @@
+from .numpy_proxy import numpy as numpy, has_numpy as has_numpy
+from .pandas_proxy import pandas as pandas
+from .sounddevice_proxy import sounddevice as sounddevice

py311/lib/python3.11/site-packages/openai/_extras/_common.py

@@ -0,0 +1,21 @@
+from .._exceptions import OpenAIError
+
+INSTRUCTIONS = """
+
+OpenAI error:
+
+    missing `{library}`
+
+This feature requires additional dependencies:
+
+    $ pip install openai[{extra}]
+
+"""
+
+
+def format_instructions(*, library: str, extra: str) -> str:
+    return INSTRUCTIONS.format(library=library, extra=extra)
+
+
+class MissingDependencyError(OpenAIError):
+    pass

py311/lib/python3.11/site-packages/openai/_extras/numpy_proxy.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from typing_extensions import override
+
+from .._utils import LazyProxy
+from ._common import MissingDependencyError, format_instructions
+
+if TYPE_CHECKING:
+    import numpy as numpy
+
+
+NUMPY_INSTRUCTIONS = format_instructions(library="numpy", extra="voice_helpers")
+
+
+class NumpyProxy(LazyProxy[Any]):
+    @override
+    def __load__(self) -> Any:
+        try:
+            import numpy
+        except ImportError as err:
+            raise MissingDependencyError(NUMPY_INSTRUCTIONS) from err
+
+        return numpy
+
+
+if not TYPE_CHECKING:
+    numpy = NumpyProxy()
+
+
+def has_numpy() -> bool:
+    try:
+        import numpy  # noqa: F401  # pyright: ignore[reportUnusedImport]
+    except ImportError:
+        return False
+
+    return True

py311/lib/python3.11/site-packages/openai/_extras/pandas_proxy.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from typing_extensions import override
+
+from .._utils import LazyProxy
+from ._common import MissingDependencyError, format_instructions
+
+if TYPE_CHECKING:
+    import pandas as pandas
+
+
+PANDAS_INSTRUCTIONS = format_instructions(library="pandas", extra="datalib")
+
+
+class PandasProxy(LazyProxy[Any]):
+    @override
+    def __load__(self) -> Any:
+        try:
+            import pandas
+        except ImportError as err:
+            raise MissingDependencyError(PANDAS_INSTRUCTIONS) from err
+
+        return pandas
+
+
+if not TYPE_CHECKING:
+    pandas = PandasProxy()