Minor performance fixes

Author: shubhamugare

syncode/grammar_decoder.py

@@ -208,12 +208,12 @@ def _get_partial_codes(self, input_ids: torch.LongTensor) -> list[(str, bytes)]:
             if self.parse_output_only:
                 partial_code, remainder_bytes = self._bytes_to_string(
                     self.byte_tokenizer.decode(
-                        input_ids[idx, self.start_from:].to('cpu', non_blocking=True).tolist(), skip_special_tokens=True)
+                        input_ids[idx, self.start_from:].tolist(), skip_special_tokens=True)
                     )
             else:
                 partial_code, remainder_bytes = self._bytes_to_string(
                     self.byte_tokenizer.decode(
-                        input_ids[idx].to('cpu', non_blocking=True).tolist(), skip_special_tokens=True)
+                        input_ids[idx].tolist(), skip_special_tokens=True)
                     )
             output.append((partial_code, remainder_bytes))
         return output

syncode/larkm/lark.py

@@ -28,7 +28,8 @@
 from .parse_tree_builder import ParseTreeBuilder
 from .parser_frontends import _validate_frontend_args, _get_lexer_callbacks, _deserialize_parsing_frontend, _construct_parsing_frontend
 from .grammar import Rule
-
+import logging
+syn_logger = logging.getLogger(__name__)
 
 try:
     import regex
@@ -349,7 +350,7 @@ def __init__(self, grammar: 'Union[Grammar, str, IO[str]]', **options) -> None:
                 except FileNotFoundError:
                     # The cache file doesn't exist; parse and compose the grammar as normal
                     if self.options.parser == 'lr':
-                        print(f"Cache file {cache_fn} not found. Building LR parser from scratch may take 2-3 minutes for large grammars. This will be cached for future runs.")
+                        syn_logger.info(f"Cache file {cache_fn} not found. Building LR parser from scratch may take 2-3 minutes for large grammars. This will be cached for future runs.")
                 except Exception: # We should probably narrow done which errors we catch here.
                     logger.exception("Failed to load Lark from cache: %r. We will try to carry on.", cache_fn)
 

syncode/larkm/parsers/lalr_interactive_parser.py

@@ -103,18 +103,19 @@ def choices(self):
     def accepts(self):
         """Returns the set of possible tokens that will advance the parser into a new valid state."""
         accepts = set()
-        conf_no_callbacks = copy(self.parser_state.parse_conf)
         # We don't want to call callbacks here since those might have arbitrary side effects
         # and are unnecessarily slow.
-        conf_no_callbacks.callbacks = {}
         choices = self.choices()
-
         if self.parser.parser_type == 'lr':
             for t in choices:
                 if t.isupper():
                     accepts.add(t)
             return accepts
 
+        # If the parser is LALR, we need to check each token to see if it's accepted
+        conf_no_callbacks = copy(self.parser_state.parse_conf)
+        conf_no_callbacks.callbacks = {}
+
         for t in choices:
             if t.isupper(): # is terminal?
                 new_cursor = copy(self)

syncode/parsers/incremental_parser.py

@@ -57,7 +57,14 @@ def _store_parser_state(self, pos: int, lexer_tokens: Iterable[Token], parser_st
         key = self._get_hash(lexer_tokens[:pos+1])
 
         # parser_state, cur_ac_terminals, next_ac_terminals, indent_levels, dedent_queue
-        self.cur_pos_to_parser_state[key] = (copy.deepcopy(self.parsed_lexer_tokens), parser_state, cur_ac_terminals, next_ac_terminals, indent_levels, copy.deepcopy(self.dedent_queue))
+        self.cur_pos_to_parser_state[key] = (
+            copy.deepcopy(self.parsed_lexer_tokens), 
+            parser_state.copy(), 
+            cur_ac_terminals, 
+            next_ac_terminals, 
+            indent_levels, 
+            copy.deepcopy(self.dedent_queue)
+        )
 
         self.cur_ac_terminals = copy.deepcopy(cur_ac_terminals)
         self.next_ac_terminals = copy.deepcopy(next_ac_terminals)
@@ -151,7 +158,7 @@ def get_acceptable_next_terminals(self, partial_code) -> ParseResult:
                 self._store_parser_state(
                     self.cur_pos-1,
                     lexer_tokens, 
-                    interactive.parser_state.copy(), 
+                    interactive.parser_state, 
                     self._accepts(interactive))
 
         except lark.exceptions.UnexpectedToken as e: