kaqing 2.0.186__py3-none-any.whl → 2.0.188__py3-none-any.whl

adam/app_session.py

@@ -8,7 +8,7 @@ from adam.log import Log
 from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.config import Config
-from adam.utils import debug, debug_trace, json_to_csv, tabulize, log, log2, log_exc
+from adam.utils import debug, debug_trace, json_to_csv, tabulize, log2, log_exc
 from adam.apps import Apps
 
 class AppLogin:

adam/embedded_params.py

@@ -1,2 +1,2 @@
 def config():
-    return {'app': {'console-endpoint': 'https://{host}/{env}/{app}/static/console/index.html', 'container-name': 'c3-server', 'cr': {'cluster-regex': '(.*?-.*?)-.*', 'group': 'ops.c3.ai', 'v': 'v2', 'plural': 'c3cassandras'}, 'label': 'c3__app_id-0', 'login': {'admin-group': '{host}/C3.ClusterAdmin', 'ingress': '{app_id}-k8singr-appleader-001', 'timeout': 5, 'session-check-url': 'https://{host}/{env}/{app}/api/8/C3/userSessionToken', 'cache-creds': True, 'cache-username': True, 'url': 'https://{host}/{env}/{app}', 'another': "You're logged in to {has}. However, for this app, you need to log in to {need}.", 'token-server-url': 'http://localhost:{port}', 'password-max-length': 128}, 'strip': '0'}, 'audit': {'endpoint': 'https://4psvtaxlcb.execute-api.us-west-2.amazonaws.com/prod/', 'workers': 3, 'timeout': 10, 'log-audit-queries': False, 'athena': {'auto-repair': {'elapsed_hours': 12}, 'region': 'us-west-2', 'catalog': 'AwsDataCatalog', 'database': 'audit', 'repair-partition-tables': 'audit', 'output': 's3://s3.ops--audit/ddl/results', 'repair-cluster-tables': 'cluster'}, 'queries': {'last10': "SELECT * FROM audit\nWHERE drive <> 'z' and ({date_condition})\nORDER BY ts DESC LIMIT {limit}", 'slow10': "SELECT * FROM audit\nWHERE drive <> 'z' and ({date_condition})\nORDER BY CAST(duration AS REAL) DESC LIMIT {limit}", 'top10': "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration\nFROM audit WHERE drive <> 'z' and ({date_condition})\nGROUP BY line ORDER BY cnt DESC LIMIT {limit}"}}, 'bash': {'workers': 32}, 'cassandra': {'service-name': 'all-pods-service'}, 'cql': {'workers': 32, 'samples': 3, 'secret': {'cluster-regex': '(.*?-.*?)-.*', 'name': '{cluster}-superuser', 'password-item': 'password'}, 'alter-tables': {'excludes': 'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema', 'gc-grace-periods': '3600,86400,864000,7776000', 'batching': True}}, 'checks': {'compactions-threshold': 250, 'cpu-busy-threshold': 98.0, 'cpu-threshold': 0.0, 'cassandra-data-path': '/c3/cassandra', 'root-disk-threshold': 50, 'cassandra-disk-threshold': 50, 'snapshot-size-cmd': "ls /c3/cassandra/data/data/*/*/snapshots | grep snapshots | sed 's/:$//g' | xargs -I {} du -sk {} | awk '{print $1}' | awk '{s+=$1} END {print s}'", 'snapshot-size-threshold': '40G', 'table-sizes-cmd': "ls -Al /c3/cassandra/data/data/ | awk '{print $9}' | sed 's/\\^r//g' | xargs -I {} du -sk /c3/cassandra/data/data/{}"}, 'download': {'workers': 8}, 'export': {'workers': 8, 'csv_dir': '/c3/cassandra/tmp', 'column_counts_query': 'select id, count(id) as columns from {table} group by id order by columns desc limit 10', 'default-importer': 'sqlite', 'sqlite': {'workers': 8, 'columns': '<row-key>', 'local-db-dir': '/tmp/qing-db'}, 'athena': {'workers': 8, 'columns': '<keys>', 'bucket': 'c3.ops--qing'}, 'csv': {'workers': 8, 'columns': '<row-key>'}, 'log-prefix': '/tmp/qing'}, 'get-host-id': {'workers': 32}, 'idps': {'ad': {'email-pattern': '.*@c3.ai', 'uri': 'https://login.microsoftonline.com/53ad779a-93e7-485c-ba20-ac8290d7252b/oauth2/v2.0/authorize?response_type=id_token&response_mode=form_post&client_id=00ff94a8-6b0a-4715-98e0-95490012d818&scope=openid+email+profile&redirect_uri=https%3A%2F%2Fplat.c3ci.cloud%2Fc3%2Fc3%2Foidc%2Flogin&nonce={nonce}&state=EMPTY', 'jwks-uri': 'https://login.microsoftonline.com/common/discovery/keys', 'contact': 'Please contact ted.tran@c3.ai.', 'whitelist-file': '/kaqing/members'}, 'okta': {'default': True, 'email-pattern': '.*@c3iot.com', 'uri': 'https://c3energy.okta.com/oauth2/v1/authorize?response_type=id_token&response_mode=form_post&client_id={client_id}&scope=openid+email+profile+groups&redirect_uri=https%3A%2F%2F{host}%2Fc3%2Fc3%2Foidc%2Flogin&nonce={nonce}&state=EMPTY', 'jwks-uri': 'https://c3energy.okta.com/oauth2/v1/keys'}}, 'issues': {'workers': 32}, 'local-tmp-dir': '/tmp/qing-db', 'logs': {'path': '/c3/cassandra/logs/system.log'}, 'log-prefix': '/tmp/qing', 'nodetool': {'workers': 96, 'commands_in_line': 40, 'status': {'workers': 32, 'samples': 3, 'commands_in_line': 40}}, 'pg': {'name-pattern': '^{namespace}.*-k8spg-.*', 'excludes': '.helm., -admin-secret', 'agent': {'name': 'ops-pg-agent', 'just-in-time': False, 'timeout': 86400, 'image': 'seanahnsf/kaqing'}, 'default-db': 'postgres', 'default-schema': 'postgres', 'secret': {'endpoint-key': 'postgres-db-endpoint', 'port-key': 'postgres-db-port', 'username-key': 'postgres-admin-username', 'password-key': 'postgres-admin-password'}}, 'pod': {'name': 'ops', 'image': 'seanahnsf/kaqing-cloud', 'sa': {'name': 'ops', 'proto': 'c3', 'additional-cluster-roles': 'c3aiops-k8ssandra-operator'}, 'label-selector': 'run=ops'}, 'preview': {'rows': 10}, 'processes': {'columns': 'pod,cpu-metrics,mem', 'header': 'POD_NAME,M_CPU(USAGE/LIMIT),MEM/LIMIT'}, 'processes-qing': {'columns': 'pod,cpu,mem', 'header': 'POD_NAME,Q_CPU/TOTAL,MEM/LIMIT'}, 'reaper': {'service-name': 'reaper-service', 'port-forward': {'timeout': 86400, 'local-port': 9001}, 'abort-runs-batch': 10, 'show-runs-batch': 100, 'pod': {'cluster-regex': '(.*?-.*?-.*?-.*?)-.*', 'label-selector': 'k8ssandra.io/reaper={cluster}-reaper'}, 'secret': {'cluster-regex': '(.*?-.*?)-.*', 'name': '{cluster}-reaper-ui', 'password-item': 'password'}}, 'repair': {'log-path': '/home/cassrepair/logs/', 'image': 'ci-registry.c3iot.io/cloudops/cassrepair:2.0.14', 'secret': 'ciregistryc3iotio', 'env': {'interval': 24, 'timeout': 60, 'pr': False, 'runs': 1}}, 'repl': {'start-drive': 'c', 'a': {'auto-enter': 'c3/c3/*'}, 'c': {'auto-enter': 'cluster'}, 'x': {'auto-enter': 'latest'}, 'history': {'push-cat-log-file': True, 'push-cat-remote-log-file': True}, 'background-process': {'auto-nohup': True}}, 'status': {'columns': 'status,address,load,tokens,owns,host_id,gossip,compactions', 'header': '--,Address,Load,Tokens,Owns,Host ID,GOSSIP,COMPACTIONS'}, 'storage': {'columns': 'pod,volume_root,volume_cassandra,snapshots,data,compactions', 'header': 'POD_NAME,VOLUME /,VOLUME CASS,SNAPSHOTS,DATA,COMPACTIONS'}, 'watch': {'auto': 'rollout', 'timeout': 3600, 'interval': 10}, 'auto-complete': {'c': {'tables': 'lazy'}, 'x': {'tables': 'lazy'}, 'cli': {'cp': 'jit'}, 'export': {'databases': 'jit'}, 'medusa': {'backups': 'jit'}, 'reaper': {'schedules': 'lazy'}}, 'debug': False, 'debugs': {'timings': False, 'exit-on-error': False, 'show-parallelism': False}}
+    return {'app': {'console-endpoint': 'https://{host}/{env}/{app}/static/console/index.html', 'container-name': 'c3-server', 'cr': {'cluster-regex': '(.*?-.*?)-.*', 'group': 'ops.c3.ai', 'v': 'v2', 'plural': 'c3cassandras'}, 'label': 'c3__app_id-0', 'login': {'admin-group': '{host}/C3.ClusterAdmin', 'ingress': '{app_id}-k8singr-appleader-001', 'timeout': 5, 'session-check-url': 'https://{host}/{env}/{app}/api/8/C3/userSessionToken', 'cache-creds': True, 'cache-username': True, 'url': 'https://{host}/{env}/{app}', 'another': "You're logged in to {has}. However, for this app, you need to log in to {need}.", 'token-server-url': 'http://localhost:{port}', 'password-max-length': 128}, 'strip': '0'}, 'audit': {'endpoint': 'https://4psvtaxlcb.execute-api.us-west-2.amazonaws.com/prod/', 'workers': 3, 'timeout': 10, 'log-audit-queries': False, 'athena': {'auto-repair': {'elapsed_hours': 12}, 'region': 'us-west-2', 'catalog': 'AwsDataCatalog', 'database': 'audit', 'repair-partition-tables': 'audit', 'output': 's3://s3.ops--audit/ddl/results', 'repair-cluster-tables': 'cluster'}, 'queries': {'last10': "SELECT * FROM audit\nWHERE drive <> 'z' and ({date_condition})\nORDER BY ts DESC LIMIT {limit}", 'slow10': "SELECT * FROM audit\nWHERE drive <> 'z' and ({date_condition})\nORDER BY CAST(duration AS REAL) DESC LIMIT {limit}", 'top10': "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration\nFROM audit WHERE drive <> 'z' and ({date_condition})\nGROUP BY line ORDER BY cnt DESC LIMIT {limit}"}}, 'bash': {'workers': 32}, 'cassandra': {'service-name': 'all-pods-service'}, 'cql': {'workers': 32, 'samples': 3, 'secret': {'cluster-regex': '(.*?-.*?)-.*', 'name': '{cluster}-superuser', 'password-item': 'password'}, 'alter-tables': {'excludes': 'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema', 'gc-grace-periods': '3600,86400,864000,7776000', 'batching': True}}, 'checks': {'compactions-threshold': 250, 'cpu-busy-threshold': 98.0, 'cpu-threshold': 0.0, 'cassandra-data-path': '/c3/cassandra', 'root-disk-threshold': 50, 'cassandra-disk-threshold': 50, 'snapshot-size-cmd': "ls /c3/cassandra/data/data/*/*/snapshots | grep snapshots | sed 's/:$//g' | xargs -I {} du -sk {} | awk '{print $1}' | awk '{s+=$1} END {print s}'", 'snapshot-size-threshold': '40G', 'table-sizes-cmd': "ls -Al /c3/cassandra/data/data/ | awk '{print $9}' | sed 's/\\^r//g' | xargs -I {} du -sk /c3/cassandra/data/data/{}"}, 'download': {'workers': 8}, 'export': {'workers': 8, 'csv_dir': '/c3/cassandra/tmp', 'column_counts_query': 'select id, count(id) as columns from {table} group by id order by columns desc limit 10', 'default-importer': 'sqlite', 'sqlite': {'workers': 8, 'columns': '<row-key>', 'local-db-dir': '/tmp/qing-db'}, 'athena': {'workers': 8, 'columns': '<keys>', 'bucket': 'c3.ops--qing'}, 'csv': {'workers': 8, 'columns': '<row-key>'}, 'log-prefix': '/tmp/qing'}, 'get-host-id': {'workers': 32}, 'idps': {'ad': {'email-pattern': '.*@c3.ai', 'uri': 'https://login.microsoftonline.com/53ad779a-93e7-485c-ba20-ac8290d7252b/oauth2/v2.0/authorize?response_type=id_token&response_mode=form_post&client_id=00ff94a8-6b0a-4715-98e0-95490012d818&scope=openid+email+profile&redirect_uri=https%3A%2F%2Fplat.c3ci.cloud%2Fc3%2Fc3%2Foidc%2Flogin&nonce={nonce}&state=EMPTY', 'jwks-uri': 'https://login.microsoftonline.com/common/discovery/keys', 'contact': 'Please contact ted.tran@c3.ai.', 'whitelist-file': '/kaqing/members'}, 'okta': {'default': True, 'email-pattern': '.*@c3iot.com', 'uri': 'https://c3energy.okta.com/oauth2/v1/authorize?response_type=id_token&response_mode=form_post&client_id={client_id}&scope=openid+email+profile+groups&redirect_uri=https%3A%2F%2F{host}%2Fc3%2Fc3%2Foidc%2Flogin&nonce={nonce}&state=EMPTY', 'jwks-uri': 'https://c3energy.okta.com/oauth2/v1/keys'}}, 'issues': {'workers': 32}, 'local-tmp-dir': '/tmp/qing-db', 'logs': {'path': '/c3/cassandra/logs/system.log'}, 'log-prefix': '/tmp/qing', 'nodetool': {'workers': 96, 'commands_in_line': 40, 'status': {'workers': 32, 'samples': 3, 'commands_in_line': 40}}, 'pg': {'name-pattern': '^{namespace}.*-k8spg-.*', 'excludes': '.helm., -admin-secret', 'agent': {'name': 'ops-pg-agent', 'just-in-time': False, 'timeout': 86400, 'image': 'seanahnsf/kaqing'}, 'default-db': 'postgres', 'default-schema': 'postgres', 'secret': {'endpoint-key': 'postgres-db-endpoint', 'port-key': 'postgres-db-port', 'username-key': 'postgres-admin-username', 'password-key': 'postgres-admin-password'}}, 'pod': {'name': 'ops', 'image': 'seanahnsf/kaqing-cloud', 'sa': {'name': 'ops', 'proto': 'c3', 'additional-cluster-roles': 'c3aiops-k8ssandra-operator'}, 'label-selector': 'run=ops'}, 'preview': {'rows': 10}, 'processes': {'columns': 'pod,cpu-metrics,mem', 'header': 'POD_NAME,M_CPU(USAGE/LIMIT),MEM/LIMIT'}, 'processes-qing': {'columns': 'pod,cpu,mem', 'header': 'POD_NAME,Q_CPU/TOTAL,MEM/LIMIT'}, 'reaper': {'service-name': 'reaper-service', 'port-forward': {'timeout': 86400, 'local-port': 9001}, 'abort-runs-batch': 10, 'show-runs-batch': 100, 'pod': {'cluster-regex': '(.*?-.*?-.*?-.*?)-.*', 'label-selector': 'k8ssandra.io/reaper={cluster}-reaper'}, 'secret': {'cluster-regex': '(.*?-.*?)-.*', 'name': '{cluster}-reaper-ui', 'password-item': 'password'}}, 'repair': {'log-path': '/home/cassrepair/logs/', 'image': 'ci-registry.c3iot.io/cloudops/cassrepair:2.0.14', 'secret': 'ciregistryc3iotio', 'env': {'interval': 24, 'timeout': 60, 'pr': False, 'runs': 1}}, 'repl': {'start-drive': 'c', 'a': {'auto-enter': 'c3/c3'}, 'c': {'auto-enter': 'cluster'}, 'x': {'auto-enter': 'latest'}, 'history': {'push-cat-log-file': True, 'push-cat-remote-log-file': True}, 'background-process': {'auto-nohup': True}}, 'status': {'columns': 'status,address,load,tokens,owns,host_id,gossip,compactions', 'header': '--,Address,Load,Tokens,Owns,Host ID,GOSSIP,COMPACTIONS'}, 'storage': {'columns': 'pod,volume_root,volume_cassandra,snapshots,data,compactions', 'header': 'POD_NAME,VOLUME /,VOLUME CASS,SNAPSHOTS,DATA,COMPACTIONS'}, 'watch': {'auto': 'rollout', 'timeout': 3600, 'interval': 10}, 'auto-complete': {'c': {'tables': 'lazy'}, 'x': {'tables': 'lazy'}, 'cli': {'cp': 'jit'}, 'export': {'databases': 'jit'}, 'medusa': {'backups': 'jit'}, 'reaper': {'schedules': 'lazy'}}, 'debug': False, 'debugs': {'timings': False, 'exit-on-error': False, 'show-parallelism': False}}

adam/sql/lark_completer.py

@@ -176,6 +176,8 @@ class LarkCompleter(Completer, AppendableCompleter):
             # for lazy completions
             self.nested = NestedCompleter.from_nested_dict(self.options_lambda())
 
+        nested_words = set()
+
         if self.nested:
             # from NestedCompleter
 
@@ -200,6 +202,7 @@ class LarkCompleter(Completer, AppendableCompleter):
                     )
 
                     for c in completer.get_completions(new_document, complete_event):
+                        nested_words.add(c.text)
                         yield c
 
             # No space in the input: behave exactly like `WordCompleter`.
@@ -208,6 +211,7 @@ class LarkCompleter(Completer, AppendableCompleter):
                     list(self.nested.options.keys()), ignore_case=self.nested.ignore_case
                 )
                 for c in completer.get_completions(document, complete_event):
+                    nested_words.add(c.text)
                     yield c
 
         if self.parser:
@@ -244,12 +248,12 @@ class LarkCompleter(Completer, AppendableCompleter):
             def word_matches(word: str) -> bool:
                 return word.lower().startswith(word_before_cursor)
 
-            for a in words:
-                if word_matches(a):
-                    display = self.display_dict.get(a, a)
-                    display_meta = self.meta_dict.get(a, "")
+            for word in words:
+                if word_matches(word) and word not in nested_words:
+                    display = self.display_dict.get(word, word)
+                    display_meta = self.meta_dict.get(word, "")
                     yield Completion(
-                        a,
+                        word,
                         -len(word_before_cursor),
                         display=display,
                         display_meta=display_meta,

adam/version.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-__version__ = "2.0.186"  #: the working version
+__version__ = "2.0.188"  #: the working version
 __release__ = "1.0.0"  #: the release version

{kaqing-2.0.186.dist-info → kaqing-2.0.188.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.186
+Version: 2.0.188
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.186.dist-info → kaqing-2.0.188.dist-info}/RECORD

@@ -1,12 +1,12 @@
 adam/__init__.py,sha256=is7iqn2nhRzPymhTEajITEFVyvROZ9GWfNsZX3L5g_o,45
-adam/app_session.py,sha256=4bRs1uYvaFWnWlTyQctSeR3BE2Dk0bVe509LbqvX9iE,6841
+adam/app_session.py,sha256=I2EX7eNRCP6T9u1BTVLs-5SB1ypyhSwNvVmi4nwoU-0,6836
 adam/apps.py,sha256=f1qsIOYjn4fdpCvMfOBns5YEiA5fMm7yZu3cQrK6z2M,7049
 adam/batch.py,sha256=c1FgH3-glAqBdAXMEGBe9MTHnqGFUXfsgLB1Mw9LV60,24041
 adam/cli.py,sha256=03pIZdomAu7IL-GSP6Eun_PKwwISShRAmfx6eVRPGC0,458
 adam/cli_group.py,sha256=W3zy1BghCtVcEXizq8fBH-93ZRVVwgAyGPzy0sHno1Y,593
 adam/config.py,sha256=snozVzu-jaws8PFMNH489Iv-43ptYa5pp4aGeTKRQnw,2778
 adam/embedded_apps.py,sha256=lKPx63mKzJbNmwz0rgL4gF76M9fDGxraYTtNAIGnZ_s,419
-adam/embedded_params.py,sha256=hHFebMjFpWuviGC6n6AsLDxm4nC8fsqEcCg1mvyUa8c,6429
+adam/embedded_params.py,sha256=NaD3Oc5LGfT2QRK_S3bOv9O4Ii8kb2JMU1pGxztmW2Q,6427
 adam/log.py,sha256=vcJ1Q8LLnt3NSXqpVcKjAI2OZE6KaD3PEi1kfu_D8qs,1156
 adam/pod_exec_result.py,sha256=85jy_5dS6TEEk5ijU0B62YfUycxmD3dG8mhIHFPipc8,1260
 adam/repl.py,sha256=_GVboHyXRcpr0l0gQAgiQ5LNTXgH3cXSvvC_aNxQmDw,7574
@@ -20,7 +20,7 @@ adam/utils_issues.py,sha256=nWhzUXmD2IfbT8MzjdyvuvpKrtUoieF74O2joaWFpUU,1438
 adam/utils_local.py,sha256=3RIvP5ZluJhOl-z9qi5U4bLFP5_vuYGnjcY-koO40lE,109
 adam/utils_net.py,sha256=byEtNVr8iG9UaD7dM77dN2WEBClB7YNKult7LKFTCOc,428
 adam/utils_sqlite.py,sha256=z34AxQL1HZBcv704NXZsMerWt-BPtnCUUw1rZHQB9Bw,4330
-adam/version.py,sha256=hUfNKxhSPSB0USqdoJrnbKI5GTxNGYyhIVYwoyw1oSE,140
+adam/version.py,sha256=BINgYFo4SHBKqDKm610CdGiykSH7P1Tcc7tYM9JtmmY,140
 adam/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/checks/check.py,sha256=Qopr3huYcMu2bzQgb99dEUYjFzkjKHRI76S6KA9b9Rk,702
 adam/checks/check_context.py,sha256=FEHkQ32jY1EDopQ2uYWqy9v7aEEX1orLpJWhopwAlh4,402
@@ -205,7 +205,7 @@ adam/commands/show/show_params.py,sha256=6rM9IgHusa5MrqLdHOBzBMOh1mOnlkFDbZeFGdX
 adam/commands/show/show_processes.py,sha256=bkdFF8fvnNCZ1YTe1ucxtKDTt40w1lLOHbx8FcshyEI,2378
 adam/commands/show/show_storage.py,sha256=AfqOn9ypo4G762aN8a5ZWW4IUpPDehM6R3QByGCpMFk,1734
 adam/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adam/sql/lark_completer.py,sha256=X8ZzYHzUy8ATsA6a4c84t9D_Jya1BGKKpvOxtKr5pvk,12309
+adam/sql/lark_completer.py,sha256=RrL4OK_3pmYXPMxWO29xikSlt1v1Z3bAWsTv9e9Wu_c,12480
 adam/sql/lark_parser.py,sha256=oNuPKfVTS1QBJ0wB3OXhBydmzgdCDED3LAheRM5cbiM,21378
 adam/sql/sql_completer.py,sha256=RO-S4OiBuDPUL8EWiymB8JexIwgwNXx1QzErDxuL3y4,3939
 adam/sql/sql_state_machine.py,sha256=3m8JsIg_tojwaHY5AdPl6UEE4ZnB5hbhOOApFfozhVo,39144
@@ -243,8 +243,11 @@ adam/utils_repl/appendable_completer.py,sha256=byLO9pZXExi13i6-fKY6gNzK-v0RtxIQt
 adam/utils_repl/automata_completer.py,sha256=LJP_2WHHR7AtjX00MJ59VGQEL3t0XS-qYnDmMaZe-Tk,1641
 adam/utils_repl/repl_completer.py,sha256=Zrs3RVVP7k6zacj1pKpYpSF6LOpziEA15yIuc5Nj3_4,6544
 adam/utils_repl/state_machine.py,sha256=kO4_oSi_M53f3QQjINzzb2VFptjbnqX3KRC0G8LqqeA,5426
-kaqing-2.0.186.dist-info/METADATA,sha256=_75gW9xjpD0_DaYD6-_9W2LYI-U4N6QOGlc1mRU8hiY,133
-kaqing-2.0.186.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-kaqing-2.0.186.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
-kaqing-2.0.186.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
-kaqing-2.0.186.dist-info/RECORD,,
+teddy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+teddy/lark_parser.py,sha256=1ZasiCM94C0nOA4HFJX7uMj0h2TReCMqLd1Wx9C50uA,14701
+teddy/lark_parser2.py,sha256=tXM6D8BimgG4FK5ANYS2K8MoATdcYed5QOKXivbPQHw,21499
+kaqing-2.0.188.dist-info/METADATA,sha256=QG9vHSpDDVhqBqKybXo3hiyXNIzrBhfU_IX-Kb6ZMdI,133
+kaqing-2.0.188.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+kaqing-2.0.188.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
+kaqing-2.0.188.dist-info/top_level.txt,sha256=spQlE6mz0lPv3DfQLw8FenXyU0O-P8pi_FUCjdI2H9s,11
+kaqing-2.0.188.dist-info/RECORD,,

kaqing-2.0.188.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+adam
+teddy

teddy/lark_parser.py

@@ -0,0 +1,436 @@
+from copy import copy
+import re
+from typing import Union, cast
+from lark import Lark, Token, Tree
+from lark.lexer import TerminalDef
+from lark.grammar import NonTerminal, Terminal
+
+def log(msg: str = None, debug: bool = False, depth: int = 0):
+    if not msg:
+        print()
+        return
+
+    if debug:
+        print(depth * '  ' + msg)
+
+class GNode:
+    def __init__(self, name: str, token: Token = None, choices: list[int] = []):
+        self.name = name
+        self.token = token
+        self.choices = choices
+
+    def __eq__(self, other: 'GNode'):
+        return self.__repr__() == other.__repr__()
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        n = self.name if self.name else f'{self.token}'
+        if self.choices:
+            n = f'{n}-{"-".join([f"{c}" for c in self.choices])}'
+
+        return n
+
+    def pname(self):
+        return self.name if self.name else f'{self.token}'
+
+    def choice(self, depth: int):
+        if depth < len(self.choices):
+            return self.choices[depth]
+
+        return -1
+
+    def drop_last_choice(self):
+        new_node = copy(self)
+        new_node.choices = self.choices[:-1]
+
+        return new_node
+
+    def parse(s: str):
+        name_n_choices = s.split('-')
+        choices = []
+        if len(name_n_choices) > 1:
+            choices = {int(k) for k in name_n_choices[1:]}
+
+        return GNode(name_n_choices[0], choices=choices)
+
+    def add_choice(self, choice: int):
+        self.choices.append(choice)
+
+class GPath:
+    def __init__(self, nodes: list[GNode], complete: bool):
+        self.nodes = nodes
+        self.complete = complete
+
+    def __eq__(self, other: 'GPath'):
+        return self.__repr__() == other.__repr__()
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        r = '.'.join([f'{p}' for p in self.nodes])
+
+        return r
+
+    def token(self):
+        return self.nodes[-1] if self.nodes else GNode(None, choices={})
+
+    def append(self, node):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes:
+            n1 = copy(n)
+            ss = []
+            for k in n.choices:
+                ss.append(k)
+            n1.choices = ss
+            nodes.append(n1)
+        nodes.append(node)
+        new_path.nodes = nodes
+
+        return new_path
+
+    def drop_last(self):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes[:-1]:
+            nodes.append(n)
+
+        new_path.nodes = nodes
+
+        return new_path
+
+    def clone(self):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes:
+            n1 = copy(n)
+            ss = []
+            for k in n.choices:
+                ss.append(k)
+            n1.choices = ss
+            nodes.append(n1)
+        new_path.nodes = nodes
+
+        return new_path
+
+    def terminal(self):
+        last_node = self.nodes[-1]
+        return last_node.pname()
+
+    def terminals(paths: set['GPath']):
+        return ','.join(p.terminal() for p in list(paths))
+
+    def with_new_choice(self, choice: int):
+        new_path = self.clone()
+        new_path.nodes[-1].add_choice(choice)
+
+        return new_path
+
+    def with_next_choice(self):
+        new_path = self.clone()
+        new_path.nodes[-1].choices[-1] += 1
+
+        return new_path
+
+    def drop_last_choice(self):
+        new_path = self.clone()
+        new_path.nodes[-1] = new_path.nodes[-1].drop_last_choice()
+
+        return new_path
+
+class LarkParser:
+    show_returns = False
+
+    def __init__(self, grammar: str = None):
+        if not grammar:
+            grammar = """
+                start: expression
+                expression: term (("+" | "-") term)*
+                term: factor (("*" | "/") factor)*
+                factor: NUMBER | "(" expression ")"
+                NUMBER: /[0-9]+/
+                %ignore " "
+            """
+
+        parser = Lark(grammar, start='start')
+        self.parser = parser
+
+        self.rules = {rule_def[0]: rule_def[2] for rule_def in parser.grammar.rule_defs}
+        self.terminals = {rule_def[0]: rule_def[1] for rule_def in parser.grammar.term_defs}
+        self.rules_by_name1 = {rule_def[0]: rule_def[1] for rule_def in parser.grammar.rule_defs}
+        self.rules_by_name2 = {rule_def[0]: rule_def[3] for rule_def in parser.grammar.rule_defs}
+
+        self.trees: dict[str, Tree] = {}
+
+    def find_next_terminals(self, path: GPath, debug=False):
+        if path == 'start':
+            return self.visit_current(LarkParser.build_path(path), debug=debug)
+
+        if isinstance(path, set):
+            paths = set()
+
+            for p in list(path):
+                paths |= self.visit_next(p, debug=debug)
+
+            return paths
+        elif isinstance(path, str):
+            path = LarkParser.build_path(path)
+
+        if debug: print(f'find_next_terminals({path}, {path.token().token})')
+
+        return self.visit_next(path, debug=debug)
+
+    def visit_current(self, path: GPath, tree: Tree = None, debug=False):
+        paths: set[GPath] = set()
+
+        if debug: print(f'visit_expansion({path}, {path.token().token}), {path.nodes[-1].choices}')
+        if not tree:
+            tree, _ = self.tree_by_choices(path, debug=debug)
+
+        if isinstance(tree, Token):
+            if debug: print('token', tree)
+            if path.nodes[-1].token:
+                path = path.drop_last()
+
+            p = path.append(GNode(name=self.token_name_from_raw(f'{tree}'), token=tree, choices=[]))
+            if LarkParser.show_returns: print('<- ', tree.value, '\t\t', p)
+            paths.add(p)
+        elif isinstance(tree, Terminal):
+            if debug: print('terminal', tree.name)
+            p = path.append(GNode(tree.name, choices=[]))
+            if LarkParser.show_returns: print('<- ', tree.name, '\t\t', p)
+            paths.add(p)
+        elif isinstance(tree, NonTerminal):
+            if debug: print('non-termial', tree.name, tree)
+            paths |= self.visit_current(path.append(GNode(tree.name, choices=[])), debug=debug)
+        elif isinstance(tree, tuple):
+            paths |= self.visit_current(path, tree=tree[0], debug=debug)
+        elif not tree:
+            raise Exception(f'null tree at {path}')
+        elif tree.data == 'expr':
+            paths |= self.visit_current(path.with_new_choice(0), tree=tree.children[0], debug=debug)
+
+            if cast(Token, tree.children[1]).value in ['*', '?']:
+                paths |= self.visit_next(path, debug=debug)
+        elif tree.data == 'value':
+            # print('value')
+            for child in tree.children:
+                paths |= self.visit_current(path, tree=child, debug=debug)
+        elif tree.data == 'range':
+            # print('range')
+            token0: Token = tree.children[0]
+            token1: Token = tree.children[1]
+            if token0.value == '"0"' and token1.value == '"9"':
+                p = path.append(GNode(name=self.token_name_from_raw(f'{token0}'), token=token0, choices=[]))
+                if LarkParser.show_returns: print('<- ', 0, '\t\t', p)
+                paths.add(p)
+            else:
+                raise Exception('not implented')
+                for i in range(ord(token0.value.strip('"')), ord(token1.value.strip('"')) + 1):
+                    ch = chr(i)
+                    p = path.append(GNode(name=self.token_name_from_raw(f'{token0}'), token=token0, choices=[]))
+                    # p = path.append(GNode(name=self.token_name_from_raw(f'{tree}'), token=tree, choices=[]))
+                    if LarkParser.show_returns: print('<- ', ch, '\t\t', p)
+                    paths.add(p)
+        elif tree.data == 'literal':
+            # print('literal')
+            for child in tree.children:
+                paths |= self.visit_current(path, tree=child, debug=debug)
+        elif tree.data == 'expansions':
+            for i, child in enumerate(tree.children):
+                paths |= self.visit_current(path.with_new_choice(i), tree=child, debug=debug)
+        elif tree.data == 'expansion':
+            paths |= self.visit_current(path.with_new_choice(0), tree=tree.children[0], debug=debug)
+
+        return paths
+
+    def visit_next(self, path: GPath, debug=False):
+        paths: set[GPath] = set()
+
+        if not path.nodes:
+            return paths
+
+        path = self.strip_terminal_nodes(path)
+        node = path.nodes[-1]
+
+        me: Tree
+        parent: Tree
+        me, parent = self.tree_by_choices(path)
+
+        check_parent = True
+        if isinstance(me, Tree) and me.data == 'expr' and me.children[1] == '*':
+            if debug: print('  add expr repeat       ', path)
+            paths |= self.visit_current(path.with_new_choice(0), debug=debug)
+
+        if isinstance(parent, Tree) and parent.data == 'expansion' and (node.choices[-1] + 1) < len(parent.children):
+            np = path.with_next_choice()
+            if debug: print('  move to next sibling  ', np)
+            paths |= self.visit_current(np, debug=debug)
+            check_parent = False
+
+        if check_parent:
+            if len(node.choices) > 0:
+                p = path.drop_last_choice()
+                if debug: print('  move up to parent tree', p)
+                paths |= self.visit_next(p, debug=debug)
+            else:
+                path = path.drop_last()
+                if debug: print('  move up to parent node', path)
+                paths |= self.visit_next(path, debug=debug)
+
+        return paths
+
+    def tree_by_choices(self, path: GPath, debug=False):
+        debug = False
+
+        c = f'{path.nodes[-1]}'
+        p = f'{path.nodes[-1].drop_last_choice()}'
+        if c not in self.trees:
+            for key, value in self.trees_by_choices(path, debug=debug).items():
+                if not key:
+                    self.trees[f'{path.token().name}'] = value
+                else:
+                    self.trees[f'{path.token().name}-{key}'] = value
+
+        return self.trees[c], self.trees[p]
+
+    def trees_by_choices(self, path_or_tree: Union[GPath, Tree], choices: list[int] = [], depth: int = 0, debug=False):
+        if debug: print(f'trees_by_choices({path_or_tree}, {choices})')
+
+        if isinstance(path_or_tree, GPath):
+            n = self.find_last_rule(path_or_tree)
+            tree = self.rules[n.name]
+        else:
+            tree = path_or_tree
+
+        trees: dict[str, Tree] = {}
+
+        if isinstance(tree, Token):
+            if debug: log('tree', debug, depth)
+            pass
+        elif isinstance(tree, Terminal):
+            if debug: log('terminal', debug, depth)
+
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+
+            pass
+        elif isinstance(tree, NonTerminal):
+            if debug: log('non-terminal', debug, depth)
+            pass
+        elif isinstance(tree, tuple):
+            if debug: log('tuple', debug, depth)
+            trees |= self.trees_by_choices(tree[0], choices, depth=depth, debug=debug)
+        elif tree.data == 'expr':
+            if debug: log('expr', debug, depth)
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+
+            for child in tree.children[:1]:
+                trees |= self.trees_by_choices(child, choices + [0], depth=depth+1, debug=debug)
+        elif tree.data == 'value':
+            if debug: log('value', debug, depth)
+
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+
+            for child in tree.children:
+                trees |= self.trees_by_choices(child, choices, depth=depth+1, debug=debug)
+        elif tree.data == 'literal':
+            if debug: log('literal', debug, depth)
+
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+
+            for child in tree.children:
+                trees |= self.trees_by_choices(child, choices, depth=depth+1, debug=debug)
+        elif tree.data == 'expansions':
+            if debug: log('expansions', debug, depth)
+
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+            for i, child in enumerate(tree.children):
+                trees |= self.trees_by_choices(child, choices + [i], depth=depth+1, debug=debug)
+        elif tree.data == 'expansion':
+            if debug: log('expansion', debug, depth)
+
+            choices_str = '-'.join([f"{c}" for c in choices])
+            trees[choices_str] = tree
+            for i, child in enumerate(tree.children):
+                trees |= self.trees_by_choices(child, choices + [i], depth=depth+1, debug=debug)
+        else:
+            if debug: log('else', debug, depth)
+
+        return trees
+
+    def strip_terminal_nodes(self, path: GPath):
+        while path.nodes[-1].name not in self.rules:
+            path = path.drop_last()
+
+        return path
+
+    def find_last_rule(self, path: GPath):
+        for n in reversed(path.nodes):
+            if n.name in self.rules:
+                return n
+
+        return None
+
+    def build_path(p: str):
+        nodes = []
+        for n in p.split('.'):
+            name_n_choices = n.split('-')
+            nodes.append(GNode(name_n_choices[0], choices=[int(c) for c in name_n_choices[1:]]))
+
+        return GPath(nodes, False)
+
+    def token_name(self, token):
+        td: TerminalDef = None
+        for t in reversed(self.parser.terminals):
+            td = t
+            # print(td)
+            if td.pattern.raw == '/./':
+                if token == '.':
+                    return td.name
+            elif re.fullmatch(td.pattern.to_regexp(), token):
+                return td.name
+
+        raise Exception('cannot resolve string to a token')
+
+    def token_name_from_raw(self, raw_token):
+        td: TerminalDef = None
+        for t in reversed(self.parser.terminals):
+            if t.pattern.raw == raw_token:
+                td = t
+                return td.name
+
+        return self.token_name(raw_token.strip('"'))
+
+    def parse(self, s: str, debug=False):
+        ps = 'start'
+        ps = self.find_next_terminals(ps, debug=debug)
+
+        for token in self.parser.lex(s):
+            token_name = self.token_name(token)
+
+            ps = self.choose(ps, token_name)
+            ps = self.find_next_terminals(ps, debug=debug)
+
+        terminals = {p.terminal().strip('"') for p in ps}
+
+        # print(terminals)
+
+        return terminals
+
+    def choose(self, paths: list[GPath], token: str):
+        if LarkParser.show_returns: print(f'\n{token}\t-----------------------------')
+
+        ps = set()
+        for p in paths:
+            if f'{p.token()}' == token:
+                ps.add(p)
+
+        return ps

teddy/lark_parser2.py

@@ -0,0 +1,618 @@
+from copy import copy
+from typing import Union
+import unittest
+from lark import Lark, Token, Tree
+from lark.grammar import NonTerminal, Terminal
+
+class GNode:
+    def __init__(self, name: str, token: Token = None, choices: dict[int, int] = {}):
+        self.name = name
+        self.token = token
+        self.choices = choices
+
+    def __eq__(self, other: 'GNode'):
+        return self.__repr__() == other.__repr__()
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        n = self.name if self.name else f'{self.token}'
+        if self.choices:
+            # print(self.choices, self.choices_to_list())
+            choices = self.choices_to_list()
+            n = f'{n}-{"-".join([f"{c}" for c in choices])}'
+
+        return n
+
+    def pname(self):
+        return self.name if self.name else f'{self.token}'
+
+    def choice(self, depth: int):
+        if depth in self.choices:
+            return self.choices[depth]
+
+        return -1
+
+    def set_choice(self, depth: int, choice: int):
+        self.choices[depth] = choice
+
+    def choices_to_list(self):
+        choices = []
+
+        if self.choices:
+            for i in range(0, max(self.choices.keys()) + 1):
+                if i in self.choices:
+                    choices.append(self.choices[i])
+                else:
+                    choices.append(0)
+
+        return choices
+
+    def choice_list_to_str(self):
+        return '-'.join([f'{c}' for c in self.choices_to_list()[:-1]])
+
+    def choice_list_to_dict(self, choices: list[int]):
+        return {i: c for i, c in enumerate(choices)}
+
+    def drop_last(self):
+        new_node = copy(self)
+        choices = self.choices_to_list()[:-1]
+        new_node.choices = self.choice_list_to_dict(choices)
+
+        return new_node
+
+class GPath:
+    def __init__(self, nodes: list[GNode], complete: bool, trail: list[str] = []):
+        self.nodes = nodes
+        self.complete = complete
+        self.trail = trail
+
+    def __eq__(self, other: 'GPath'):
+        return self.__repr__() == other.__repr__()
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return '.'.join([f'{p}' for p in self.nodes])
+
+    def token(self):
+        return self.nodes[-1]
+
+    def append(self, node):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes:
+            n1 = copy(n)
+            ss = {}
+            for k, v in n.choices.items():
+                ss[k] = v
+            n1.choices = ss
+            nodes.append(n1)
+        nodes.append(node)
+        new_path.nodes = nodes
+
+        return new_path
+
+    def drop_last(self):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes[:-1]:
+            nodes.append(n)
+        new_path.nodes = nodes
+
+        return new_path
+
+    def clone(self):
+        new_path = copy(self)
+        nodes = []
+        for n in self.nodes:
+            n1 = copy(n)
+            ss = {}
+            for k, v in n.choices.items():
+                ss[k] = v
+            n1.choices = ss
+            nodes.append(n1)
+        new_path.nodes = nodes
+
+        return new_path
+
+    def terminal(self):
+        last_node = self.nodes[-1]
+        # print('SEAN', last_node.token.data)
+        return last_node.pname()
+
+    def terminals(paths: set['GPath']):
+        return ','.join(p.terminal() for p in list(paths))
+
+class CompletePath:
+    def __init__(self, path: GPath, complete: False):
+        self.path = path
+        self.complete = complete
+
+class SeqOrUnion:
+    def __init__(self, collection: list, is_seq: bool):
+        self.collection = collection
+        self.is_seq = is_seq
+
+class LarkParser:
+    def __init__(self):
+        grammar = """
+            start: expression
+            expression: term (("+" | "-") term)*
+            term: factor (("*" | "/") factor)*
+            factor: NUMBER | "(" expression ")"
+            NUMBER: /[0-9]+/
+            %ignore " "
+        """
+
+        parser = Lark(grammar, start='start')
+
+        # print('TEST parsing', parser.parse('(56)'))
+
+        # print(parser.grammar.term_defs)
+
+        for rule in parser.grammar.rule_defs + parser.grammar.term_defs:
+            lhv = rule[0]
+            # print(f'{lhv} :=')
+            # print(rule[1])
+            if len(rule) > 2:
+                tree = rule[2]
+                # print(f'{tree.pretty()}')
+                # print(rule[3])
+
+        self.rules = {rule_def[0]: rule_def[2] for rule_def in parser.grammar.rule_defs}
+        self.terminals = {rule_def[0]: rule_def[1] for rule_def in parser.grammar.term_defs}
+        self.rules_by_name1 = {rule_def[0]: rule_def[1] for rule_def in parser.grammar.rule_defs}
+        self.rules_by_name2 = {rule_def[0]: rule_def[3] for rule_def in parser.grammar.rule_defs}
+
+    def children_by_choices(self, tree: Tree, choices: list[int] = [], depth: int = 0):
+        children: dict[str, SeqOrUnion] = {}
+
+        if isinstance(tree, Token):
+            pass
+        elif isinstance(tree, Terminal):
+            pass
+        elif isinstance(tree, NonTerminal):
+            pass
+        elif isinstance(tree, tuple):
+            children |= self.children_by_choices(tree[0], choices, depth=depth)
+        elif tree.data == 'expr':
+            for child in tree.children[:1]:
+                children |= self.children_by_choices(child, choices, depth=depth)
+            # complete = False
+        elif tree.data == 'value':
+            # print('value')
+            for child in tree.children:
+                children |= self.children_by_choices(child, choices, depth=depth)
+        elif tree.data == 'literal':
+            # print('literal')
+            for child in tree.children:
+                children |= self.children_by_choices(child, choices, depth=depth)
+        elif tree.data == 'expansions':
+            # print('expansions')
+            # print(tree.pretty())
+            choices_str = '-'.join([f"{c}" for c in choices])
+            children[choices_str] = SeqOrUnion(tree.children, False)
+            # print(f'children_by_choices[{choices_str}] = {len(tree.children)}')
+            for i, child in enumerate(tree.children):
+                children |= self.children_by_choices(child, choices + [i], depth=depth+1)
+        elif tree.data == 'expansion':
+            # print('expansion')
+            # print(tree.pretty())
+            choices_str = '-'.join([f"{c}" for c in choices])
+            children[choices_str] = SeqOrUnion(tree.children, True)
+            # print(f'children_by_choices[{choices_str}] = {len(tree.children)}')
+            for i, child in enumerate(tree.children):
+                children |= self.children_by_choices(child, choices + [i], depth=depth+1)
+
+        return children
+
+    def find_next_terminals(self, path: GPath, debug=False):
+        if path == 'start':
+            return self.find_terminals(path, debug=debug)
+
+        if isinstance(path, set):
+            paths = set()
+
+            for p in list(path):
+                paths |= self.find_next_terminals(p, debug=debug)
+
+            return paths
+        elif isinstance(path, str):
+            path = LarkParser.build_path(path)
+
+        terminals = self.find_terminals(path, debug=debug)
+
+        next_terminals = set()
+
+        for t in terminals:
+            paths = self.find_next(t)
+            for path in paths:
+                terms = self.find_terminals(path, debug=debug)
+                for term in terms:
+                    term.trail.append(term.terminal())
+                next_terminals |= terms
+
+        return next_terminals
+
+    def _find_next_terminals(self, path: GPath, debug=False):
+        # terminals = self.find_terminals(path)
+
+        if isinstance(path, str):
+            path = LarkParser.build_path(path)
+
+        next_terminals = set()
+
+        # for t in terminals:
+        paths = self.find_next(path)
+        for path in paths:
+            next_terminals |= self.find_terminals(path, debug=debug)
+
+        return next_terminals
+
+    def find_next(self, path: GPath, depth: int = -1, debug=False):
+        paths: set[GPath] = set()
+
+        if not path.nodes:
+            return paths
+
+        if depth == -1:
+            if debug: print('find_next', path)
+
+        node = path.nodes[-1]
+        if node.name in self.rules:
+            tree = self.rules[node.name]
+        elif node.name in self.terminals:
+            tree = self.terminals[node.name]
+        else:
+            tree = node.token
+
+        choices = node.choices_to_list()
+        children = self.children_by_choices(tree)
+        # print('children', children)
+
+        if depth == -1:
+            depth = len(choices) - 1
+
+        # print(depth, len(choices), len(children[node.choice_list_to_str()]))
+        # print(len(choices), len(children))
+        check_parent = True
+        if children and children[node.choice_list_to_str()].is_seq and choices[depth] + 1 < len(children[node.choice_list_to_str()].collection):
+            node.choices[depth] += 1
+            if debug: print('  move to next sibling  ', path)
+            # print('paths', path.nodes[-1] )
+            paths.add(path.clone())
+            check_parent = False
+
+            next_sibing = children[node.choice_list_to_str()].collection[node.choices[depth]]
+            if next_sibing.data == 'expr':
+                paths |=  self.find_next(path, depth, debug=debug)
+                check_parent = True
+
+            # print('next_sibling', next_sibing)
+
+        if check_parent:
+            if depth > 0:
+                new_node = node.drop_last()
+                path.nodes[-1] = new_node
+                if debug: print('  move up to parent tree', new_node)
+                depth -= 1
+                paths |=  self.find_next(path, depth, debug=debug)
+            else:
+                path = path.drop_last()
+                if debug: print('  move up to parent node', path)
+                paths |= self.find_next(path, -1, debug=debug)
+
+        return paths
+
+    def find_terminals(self, path: GPath, paths: set[GPath] = set(), path_history: set[GNode] = set(), debug=False):
+        if isinstance(path, str):
+            path = LarkParser.build_path(path)
+
+        if debug: print('find_terminals', path)
+
+        path_history.add(path.nodes[-1])
+
+        paths = self._find_terminals(None, path, debug=debug)
+
+        new_paths = set()
+        for p in paths:
+            node = p.nodes[-1]
+            if node.token:
+                # print('found terminal node', node)
+                new_paths.add(p)
+            else:
+                new_paths |= self.find_terminals(p, paths, path_history, debug=debug)
+
+        return new_paths
+
+    def _find_terminals(self, tree: Tree, path: GPath, depth = 0, debug=False):
+        paths: set[GPath] = set()
+        # complete = False
+
+        node = path.nodes[-1]
+        if not tree:
+            if node.name in self.rules:
+                tree = self.rules[node.name]
+            elif node.name in self.terminals:
+                tree = self.terminals[node.name]
+            else:
+                tree = node.token
+
+        # print(tree)
+
+        if isinstance(tree, Token):
+            p = path.append(GNode(name=None, token=tree))
+            print('<- ', tree.value, '\t\t', p)
+            paths.add(p)
+        elif isinstance(tree, Terminal):
+            paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, NonTerminal):
+            # print('non-termial', tree.name)
+            paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, tuple):
+            paths |= self._find_terminals(tree[0], path, depth=depth)
+        elif tree.data == 'expr':
+            # print('expr')
+            for child in tree.children[:1]:
+                paths |= self._find_terminals(child, path, depth=depth)
+        elif tree.data == 'value':
+            # print('value')
+            for child in tree.children:
+                paths |= self._find_terminals(child, path, depth=depth)
+        elif tree.data == 'literal':
+            # print('literal')
+            for child in tree.children:
+                paths |= self._find_terminals(child, path, depth=depth)
+        elif tree.data == 'expansions':
+            if node.choice(depth) == -1:
+                for i, child in enumerate(tree.children):
+                    p = path.clone()
+                    node = p.nodes[-1]
+                    node.set_choice(depth, i)
+                    paths |= self._find_terminals(child, p, depth=depth+1)
+            else:
+                # node.set_choice(depth, node.choice(depth))
+                paths |= self._find_terminals(tree.children[node.choice(depth)], path, depth=depth+1)
+        elif tree.data == 'expansion':
+            # print('expansion', path)
+            if (choice := node.choice(depth)) == -1:
+                choice = 0
+
+            node.set_choice(depth, choice)
+            paths |= self._find_terminals(tree.children[choice], path, depth=depth+1)
+
+        return paths
+
+    def visit(self, path: GPath, paths: set[GPath] = set(), path_history: set[GNode] = set(), next = False):
+        if isinstance(path, str):
+            print('visit', path)
+            path = LarkParser.build_path(path)
+
+        # print('visit', path)
+        if path.nodes[-1] in path_history:
+            return paths
+
+        path_history.add(path.nodes[-1])
+
+        paths = self.visit_tree(None, path, next=next)
+
+        new_paths = set()
+        for p in paths:
+            node = p.nodes[-1]
+            if node.token:
+                # print('found terminal node', node)
+                new_paths.add(p)
+            else:
+                new_paths |= self.visit(p, paths, path_history, next=False)
+
+        return new_paths
+
+    def visit_tree(self, tree: Tree, path: GPath, depth = 0, next = False):
+        paths: set[GPath] = set()
+        # complete = False
+
+        node = path.nodes[-1]
+        if not tree:
+            if node.name in self.rules:
+                tree = self.rules[node.name]
+            elif node.name in self.terminals:
+                tree = self.terminals[node.name]
+            else:
+                tree = node.token
+
+        # print(tree)
+
+        if isinstance(tree, Token):
+            p = path.append(GNode(name=None, token=tree))
+            print('<- ', tree.value, '\t\t', p)
+            paths.add(p)
+        elif isinstance(tree, Terminal):
+            paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, NonTerminal):
+            # print('non-termial', tree.name)
+            paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, tuple):
+            paths |= self.visit_tree(tree[0], path, depth=depth)
+        elif tree.data == 'expr':
+            # print('SEAN expr', tree.data, tree.children[1])
+            # print('expr add extra', path)
+            # paths.add(path)
+            for child in tree.children[:1]:
+                paths |= self.visit_tree(child, path, depth=depth)
+            # complete = False
+        elif tree.data == 'value':
+            # print('value')
+            for child in tree.children:
+                paths |= self.visit_tree(child, path, depth=depth)
+        elif tree.data == 'literal':
+            # print('literal')
+            for child in tree.children:
+                paths |= self.visit_tree(child, path, depth=depth)
+        elif tree.data == 'expansions':
+            # print('expansions', path)
+            if next:
+                paths |= self.visit_tree(tree.children[node.choice(depth)], path, depth=depth+1)
+            else:
+                for i, child in enumerate(tree.children):
+                    node.set_choice(depth, i)
+                    paths |= self.visit_tree(child, path, depth=depth+1)
+        elif tree.data == 'expansion':
+            # print('expansion', path)
+            if (choice := node.choice(depth)) == -1:
+                choice = 0
+
+            node.set_choice(depth, choice)
+            paths |= self.visit_tree(tree.children[choice], path, depth=depth+1)
+
+        return paths
+
+    def _find_next(self, path: GPath, paths: set[GPath] = set(), path_history: set[GNode] = set()):
+        if isinstance(path, str):
+            print('visit_next', path)
+            path = LarkParser.build_path(path)
+
+        # print('visit', path)
+        paths: set[GPath] = set()
+
+        for i in reversed(range(1, len(path.nodes) + 1)):
+            path = GPath(path.nodes[:i], False)
+            print('testing path', path)
+
+            complete = False
+            next = self.find_tree_next(None, path)
+            if next:
+                for n in next:
+                    print('visiting with next', n)
+                    paths |= self.visit(n, paths, set(), next=True)
+                    if n.complete:
+                        complete = True
+                    else:
+                        pass
+                        # print('SEAN not complete', n)
+            # if not complete:
+            #     break
+            # if next.complete:
+            #     print('SEAN complete', next.complete)
+            #     continue
+            if next and not complete:
+                break
+
+            # else:
+            #     break
+
+        return paths
+
+    def find_tree_next(self, tree: Tree, path: GPath, depth = 0):
+        print('find_tree_next', path, depth)
+        paths: set[GPath] = set()
+        # complete = False
+
+        node = path.nodes[-1]
+        if not tree:
+            if node.name in self.rules:
+                tree = self.rules[node.name]
+            elif node.name in self.terminals:
+                tree = self.terminals[node.name]
+            else:
+                tree = node.token
+
+        if isinstance(tree, Token):
+            path.complete = True
+            pass
+            # print('token found', tree.value)
+        elif isinstance(tree, Terminal):
+            path.complete = True
+            pass
+            # paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, NonTerminal):
+            pass
+            # print('non-termial', tree.name)
+            # paths.add(path.append(GNode(tree.name)))
+        elif isinstance(tree, tuple):
+            paths |= self.find_tree_next(tree[0], path, depth=depth)
+        elif tree.data == 'expr':
+            print(" " * depth, 'expr')
+            paths.add(path)
+            for child in tree.children[:1]:
+                paths |= self.find_tree_next(child, path, depth=depth)
+            # complete = False
+        elif tree.data == 'value':
+            print(" " * depth, 'value')
+            for child in tree.children:
+                paths |= self.find_tree_next(child, path, depth=depth)
+        elif tree.data == 'literal':
+            print(" " * depth, 'literal')
+            for child in tree.children:
+                paths |= self.find_tree_next(child, path, depth=depth)
+        elif tree.data == 'expansions':
+            print(" " * depth, 'expansions')
+            child = tree.children[node.choice(depth)]
+            path = self.find_tree_next(child, path, depth=depth+1)
+            if node.choices[depth] + 1 < len(tree.children):
+                node.choices[depth] += 1
+
+            paths |= path
+
+            # for i, child in enumerate(tree.children):
+            #     # self.set_next_choice(path.nodes[-1], depth)
+            #     paths |= self.visit_tree_next(child, rules, terminals, path, depth=depth+1)
+        elif tree.data == 'expansion':
+            print(" " * depth, 'expansion')
+            child = tree.children[node.choice(depth)]
+            if depth < len(node.choices) -1:
+                path = self.find_tree_next(child, path, depth=depth+1)
+                if node.choices[depth] + 1 < len(tree.children):
+                    node.choices[depth] += 1
+
+                paths |= path
+            # else:
+            #     if len(tree.children) > node.choices[depth] + 1:
+            #         node.choices[depth] += 1
+            #         if tree.children[node.choices[depth]].data == 'expr':
+            #             print('SEAN expr')
+            #             # np = path.drop_last()
+            #             # print('SEAN next choice', np)
+            #             # paths.add(np)
+            #             path.complete = True
+            #             paths.add(path)
+
+            #         # self.set_next_choice(node, depth)
+            #         paths.add(path)
+
+
+            # print(" " * depth, 'expansion', path)
+            # print('SEAN expansion', tree.pretty())
+            # if len(tree.children) > node.choices[depth] + 1:
+            #     # print('next child found', tree.children, depth)
+
+            #     node.choices[depth] += 1
+            #     if tree.children[node.choices[depth]].data == 'expr':
+            #         print('SEAN expr')
+            #         # np = path.drop_last()
+            #         # print('SEAN next choice', np)
+            #         # paths.add(np)
+            #         path.complete = True
+            #         paths.add(path)
+
+            #     # self.set_next_choice(node, depth)
+            #     paths.add(path)
+
+            #     # print('SEAN returning', path)
+
+            #     return paths
+            # else:
+            #     path.complete = True
+
+        # print('returning', paths)
+        return paths
+
+    def build_path(p: str):
+        nodes = []
+        for n in p.split('.'):
+            name_n_choices = n.split('-')
+            nodes.append(GNode(name_n_choices[0], choices={int(k): int(v) for k, v in enumerate(name_n_choices[1:])}))
+
+        return GPath(nodes, False)

kaqing-2.0.186.dist-info/top_level.txt

@@ -1 +0,0 @@
-adam