

from __future__ import annotations

import time

lowercase_									=   list[tuple[int, int]]

lowercase_									=   [
    [0, 0, 0, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0],
    [1, 0, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 1, 0, 0],
]

lowercase_									=   [[-1, 0], [0, -1], [1, 0], [0, 1]]  # up, left, down, right





class  __lowerCAmelCase     :




  def __init__(				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase					)  -> str:
        '''simple docstring'''






        _lowercase	       =pos_x
        _lowercase	       =pos_y
        _lowercase	       =(pos_y, pos_x)
        _lowercase	       =goal_x
        _lowercase	       =goal_y
        _lowercase	       =parent





class  __lowerCAmelCase     :




  def __init__(				self							,   lowerCAmelCase							,   lowerCAmelCase					)  -> Optional[Any]:
        '''simple docstring'''






        _lowercase	       =Node(start[1]							,   start[0]							,   goal[1]							,   goal[0]							,   lowerCAmelCase					)
        _lowercase	       =Node(goal[1]							,   goal[0]							,   goal[1]							,   goal[0]							,   lowerCAmelCase					)

        _lowercase	       =[self.start]
        _lowercase	       =False




  def   A__     (				self					)  -> Path | None:
        '''simple docstring'''






        while self.node_queue:
              _lowercase	       =self.node_queue.pop(0					)

              if current_node.pos == self.target.pos:
                    _lowercase	       =True
                    return self.retrace_path(lowerCAmelCase					)

              _lowercase	       =self.get_successors(lowerCAmelCase					)

              for node in successors:
                    self.node_queue.append(lowerCAmelCase					)

        if not self.reached:
              return [self.start.pos]
        return None




  def   A__     (				self							,   lowerCAmelCase					)  -> list[Node]:
        '''simple docstring'''






        _lowercase	       =[]
        for action in delta:
              _lowercase	       =parent.pos_x + action[1]
              _lowercase	       =parent.pos_y + action[0]
              if not (0 <= pos_x <= len(grid[0]					) - 1 and 0 <= pos_y <= len(lowerCAmelCase					) - 1):
                    continue

              if grid[pos_y][pos_x] != 0:
                    continue

              successors.append(
                  Node(lowerCAmelCase							,   lowerCAmelCase							,   self.target.pos_y							,   self.target.pos_x							,   lowerCAmelCase					)					)
        return successors




  def   A__     (				self							,   lowerCAmelCase					)  -> Path:
        '''simple docstring'''






        _lowercase	       =node
        _lowercase	       =[]
        while current_node is not None:
              path.append((current_node.pos_y, current_node.pos_x)					)
              _lowercase	       =current_node.parent
        path.reverse()
        return path





class  __lowerCAmelCase     :




  def __init__(				self							,   lowerCAmelCase							,   lowerCAmelCase					)  -> str:
        '''simple docstring'''






        _lowercase	       =BreadthFirstSearch(lowerCAmelCase							,   lowerCAmelCase					)
        _lowercase	       =BreadthFirstSearch(lowerCAmelCase							,   lowerCAmelCase					)
        _lowercase	       =False




  def   A__     (				self					)  -> Path | None:
        '''simple docstring'''






        while self.fwd_bfs.node_queue or self.bwd_bfs.node_queue:
              _lowercase	       =self.fwd_bfs.node_queue.pop(0					)
              _lowercase	       =self.bwd_bfs.node_queue.pop(0					)

              if current_bwd_node.pos == current_fwd_node.pos:
                    _lowercase	       =True
                    return self.retrace_bidirectional_path(
                        lowerCAmelCase							,   lowerCAmelCase					)

              _lowercase	       =current_bwd_node
              _lowercase	       =current_fwd_node

              _lowercase	       ={
                  self.fwd_bfs: self.fwd_bfs.get_successors(lowerCAmelCase					),
                  self.bwd_bfs: self.bwd_bfs.get_successors(lowerCAmelCase					),
              }

              for bfs in [self.fwd_bfs, self.bwd_bfs]:
                    for node in successors[bfs]:
                          bfs.node_queue.append(lowerCAmelCase					)

        if not self.reached:
              return [self.fwd_bfs.start.pos]
        return None




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase					)  -> Path:
        '''simple docstring'''






        _lowercase	       =self.fwd_bfs.retrace_path(lowerCAmelCase					)
        _lowercase	       =self.bwd_bfs.retrace_path(lowerCAmelCase					)
        bwd_path.pop()
        bwd_path.reverse()
        _lowercase	       =fwd_path + bwd_path
        return path


if __name__ == "__main__":
  # all coordinates are given in format [y,x]
  import doctest

  doctest.testmod()
  lowercase_									=   (0, 0)
  lowercase_									=   (len(grid) - 1, len(grid[0]) - 1)
  for elem in grid:
    print(elem)

  lowercase_									=   time.time()
  lowercase_									=   BreadthFirstSearch(init, goal)
  lowercase_									=   bfs.search()
  lowercase_									=   time.time() - start_bfs_time

  print('Unidirectional BFS computation time : ', bfs_time)

  lowercase_									=   time.time()
  lowercase_									=   BidirectionalBreadthFirstSearch(init, goal)
  lowercase_									=   bd_bfs.search()
  lowercase_									=   time.time() - start_bd_bfs_time

  print('Bidirectional BFS computation time : ', bd_bfs_time)





import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
lowercase_									=   data_utils.TransfoXLTokenizer
lowercase_									=   data_utils.TransfoXLCorpus
lowercase_									=   data_utils
lowercase_									=   data_utils
def      a      (			A__	:   int      ,   A__	:   Dict      ,   A__	:   Union[str, Any]      ,   A__	:   Union[str, Any]     )    ->      List[str]:





      """simple docstring"""



      if transfo_xl_dataset_file:
            # Convert a pre-processed corpus (see original TensorFlow repo)
            with open(A__      ,   'rb'     ) as fp:
                  _lowercase	       =pickle.load(A__      ,   encoding='latin1'     )
            # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
            _lowercase	       =pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
            print(F'''Save vocabulary to {pytorch_vocab_dump_path}'''     )
            _lowercase	       =corpus.vocab.__dict__
            torch.save(A__      ,   A__     )

            _lowercase	       =corpus.__dict__
            corpus_dict_no_vocab.pop('vocab'      ,   A__     )
            _lowercase	       =pytorch_dump_folder_path + '/' + CORPUS_NAME
            print(F'''Save dataset to {pytorch_dataset_dump_path}'''     )
            torch.save(A__      ,   A__     )

      if tf_checkpoint_path:
            # Convert a pre-trained TensorFlow model
            _lowercase	       =os.path.abspath(A__     )
            _lowercase	       =os.path.abspath(A__     )

            print(F'''Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'''     )
            # Initialise PyTorch model
            if transfo_xl_config_file == "":
                  _lowercase	       =TransfoXLConfig()
            else:
                  _lowercase	       =TransfoXLConfig.from_json_file(A__     )
            print(F'''Building PyTorch model from configuration: {config}'''     )
            _lowercase	       =TransfoXLLMHeadModel(A__     )

            _lowercase	       =load_tf_weights_in_transfo_xl(A__      ,   A__      ,   A__     )
            # Save pytorch-model
            _lowercase	       =os.path.join(A__      ,   A__     )
            _lowercase	       =os.path.join(A__      ,   A__     )
            print(F'''Save PyTorch model to {os.path.abspath(A__     )}'''     )
            torch.save(model.state_dict()      ,   A__     )
            print(F'''Save configuration file to {os.path.abspath(A__     )}'''     )
            with open(A__      ,   'w'      ,   encoding='utf-8'     ) as f:
                  f.write(config.to_json_string()     )


if __name__ == "__main__":
  lowercase_									=   argparse.ArgumentParser()
  parser.add_argument(
      '--pytorch_dump_folder_path',
      default=None,
      type=str,
      required=True,
      help='Path to the folder to store the PyTorch model or dataset/vocab.',
  )
  parser.add_argument(
      '--tf_checkpoint_path',
      default='',
      type=str,
      help='An optional path to a TensorFlow checkpoint path to be converted.',
  )
  parser.add_argument(
      '--transfo_xl_config_file',
      default='',
      type=str,
      help=(
          'An optional config json file corresponding to the pre-trained BERT model. \n'
          'This specifies the model architecture.'
      ),
  )
  parser.add_argument(
      '--transfo_xl_dataset_file',
      default='',
      type=str,
      help='An optional dataset file to be converted in a vocabulary.',
  )
  lowercase_									=   parser.parse_args()
  convert_transfo_xl_checkpoint_to_pytorch(
      args.tf_checkpoint_path,
      args.transfo_xl_config_file,
      args.pytorch_dump_folder_path,
      args.transfo_xl_dataset_file,
  )


