

'''simple docstring'''






import argparse
import os
import re

import packaging.version


lowerCAmelCase__											=	'''examples/'''
lowerCAmelCase__											=	{
    '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''),
    '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
lowerCAmelCase__											=	{
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
lowerCAmelCase__											=	'''README.md'''


def 		_A     (    A__     ,				A__     ,				A__      ):






 """simple docstring"""



 with open(A__     ,				'''r'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  __lowercase							  = f.read()
 __lowercase  ,	__lowercase							  = REPLACE_PATTERNS[pattern]
 __lowercase							  = replace.replace('''VERSION'''     ,				A__      )
 __lowercase							  = re_pattern.sub(A__     ,				A__      )
 with open(A__     ,				'''w'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  f.write(A__      )


def 		_A     (    A__      ):






 """simple docstring"""



 for folder, directories, fnames in os.walk(A__      ):
  # Removing some of the folders with non-actively maintained examples from the walk
  if "research_projects" in directories:
   directories.remove('''research_projects'''      )
  if "legacy" in directories:
   directories.remove('''legacy'''      )
  for fname in fnames:
   if fname.endswith('''.py'''      ):
    update_version_in_file(os.path.join(A__     ,				A__      )     ,				A__     ,				pattern='''examples'''      )


def 		_A     (    A__     ,				A__=False      ):






 """simple docstring"""



 for pattern, fname in REPLACE_FILES.items():
  update_version_in_file(A__     ,				A__     ,				A__      )
 if not patch:
  update_version_in_examples(A__      )


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = '''🤗 Transformers currently provides the following architectures'''
 __lowercase							  = '''1. Want to contribute a new model?'''
 with open(A__     ,				'''r'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  __lowercase							  = f.readlines()

 # Find the start of the list.
 __lowercase							  = 0
 while not lines[start_index].startswith(_start_prompt      ):
  start_index += 1
 start_index += 1

 __lowercase							  = start_index
 # Update the lines in the model list.
 while not lines[index].startswith(_end_prompt      ):
  if lines[index].startswith('''1.'''      ):
   __lowercase							  = lines[index].replace(
       '''https://huggingface.co/docs/transformers/main/model_doc'''     ,				'''https://huggingface.co/docs/transformers/model_doc'''     ,				)
  index += 1

 with open(A__     ,				'''w'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  f.writelines(A__      )


def 		_A     (    ):






 """simple docstring"""



 with open(REPLACE_FILES['''init''']     ,				'''r'''      ) as f:
  __lowercase							  = f.read()
 __lowercase							  = REPLACE_PATTERNS['''init'''][0].search(A__      ).groups()[0]
 return packaging.version.parse(A__      )


def 		_A     (    A__=False      ):






 """simple docstring"""



 __lowercase							  = get_version()
 if patch and default_version.is_devrelease:
  raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''      )
 if default_version.is_devrelease:
  __lowercase							  = default_version.base_version
 elif patch:
  __lowercase							  = F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
 else:
  __lowercase							  = F"{default_version.major}.{default_version.minor + 1}.0"

 # Now let's ask nicely if that's the right one.
 __lowercase							  = input(F"Which version are you releasing? [{default_version}]"      )
 if len(A__      ) == 0:
  __lowercase							  = default_version

 print(F"Updating version to {version}."      )
 global_version_update(A__     ,				patch=A__      )
 if not patch:
  print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''      )
  clean_main_ref_in_model_list()


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = get_version()
 __lowercase							  = F"{current_version.major}.{current_version.minor + 1}.0.dev0"
 __lowercase							  = current_version.base_version

 # Check with the user we got that right.
 __lowercase							  = input(F"Which version are we developing now? [{dev_version}]"      )
 if len(A__      ) == 0:
  __lowercase							  = dev_version

 print(F"Updating version to {version}."      )
 global_version_update(A__      )
 print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''      )
 clean_main_ref_in_model_list()


if __name__ == "__main__":
 lowerCAmelCase__											=	argparse.ArgumentParser()
 parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
 parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
 lowerCAmelCase__											=	parser.parse_args()
 if not args.post_release:
  pre_release_work(patch=args.patch)
 elif args.patch:
  print('''Nothing to do after a patch :-)''')
 else:
  post_release_work()




'''simple docstring'''






from __future__ import annotations

from decimal import Decimal

from numpy import array


def 		_A     (    A__      ):






 """simple docstring"""



 __lowercase							  = Decimal

 # Check if the provided matrix has 2 rows and 2 columns
 # since this implementation only works for 2x2 matrices
 if len(A__      ) == 2 and len(matrix[0]      ) == 2 and len(matrix[1]      ) == 2:
  # Calculate the determinant of the matrix
  __lowercase							  = float(
      d(matrix[0][0]      ) * d(matrix[1][1]      ) - d(matrix[1][0]      ) * d(matrix[0][1]      )      )
  if determinant == 0:
   raise ValueError('''This matrix has no inverse.'''      )

  # Creates a copy of the matrix with swapped positions of the elements
  __lowercase							  = [[0.0, 0.0], [0.0, 0.0]]
  __lowercase  ,	__lowercase							  = matrix[1][1], matrix[0][0]
  __lowercase  ,	__lowercase							  = -matrix[1][0], -matrix[0][1]

  # Calculate the inverse of the matrix
  return [
      [(float(d(A__      )      ) / determinant) or 0.0 for n in row] for row in swapped_matrix
  ]
 elif (
     len(A__      ) == 3
     and len(matrix[0]      ) == 3
     and len(matrix[1]      ) == 3
     and len(matrix[2]      ) == 3
 ):
  # Calculate the determinant of the matrix using Sarrus rule
  __lowercase							  = float(
      (
          (d(matrix[0][0]      ) * d(matrix[1][1]      ) * d(matrix[2][2]      ))
          + (d(matrix[0][1]      ) * d(matrix[1][2]      ) * d(matrix[2][0]      ))
          + (d(matrix[0][2]      ) * d(matrix[1][0]      ) * d(matrix[2][1]      ))
      )
      - (
          (d(matrix[0][2]      ) * d(matrix[1][1]      ) * d(matrix[2][0]      ))
          + (d(matrix[0][1]      ) * d(matrix[1][0]      ) * d(matrix[2][2]      ))
          + (d(matrix[0][0]      ) * d(matrix[1][2]      ) * d(matrix[2][1]      ))
      )      )
  if determinant == 0:
   raise ValueError('''This matrix has no inverse.'''      )

  # Creating cofactor matrix
  __lowercase							  = [
      [d(0.0      ), d(0.0      ), d(0.0      )],
      [d(0.0      ), d(0.0      ), d(0.0      )],
      [d(0.0      ), d(0.0      ), d(0.0      )],
  ]
  __lowercase							  = (d(matrix[1][1]      ) * d(matrix[2][2]      )) - (
      d(matrix[1][2]      ) * d(matrix[2][1]      )
  )
  __lowercase							  = -(
      (d(matrix[1][0]      ) * d(matrix[2][2]      )) - (d(matrix[1][2]      ) * d(matrix[2][0]      ))
  )
  __lowercase							  = (d(matrix[1][0]      ) * d(matrix[2][1]      )) - (
      d(matrix[1][1]      ) * d(matrix[2][0]      )
  )
  __lowercase							  = -(
      (d(matrix[0][1]      ) * d(matrix[2][2]      )) - (d(matrix[0][2]      ) * d(matrix[2][1]      ))
  )
  __lowercase							  = (d(matrix[0][0]      ) * d(matrix[2][2]      )) - (
      d(matrix[0][2]      ) * d(matrix[2][0]      )
  )
  __lowercase							  = -(
      (d(matrix[0][0]      ) * d(matrix[2][1]      )) - (d(matrix[0][1]      ) * d(matrix[2][0]      ))
  )
  __lowercase							  = (d(matrix[0][1]      ) * d(matrix[1][2]      )) - (
      d(matrix[0][2]      ) * d(matrix[1][1]      )
  )
  __lowercase							  = -(
      (d(matrix[0][0]      ) * d(matrix[1][2]      )) - (d(matrix[0][2]      ) * d(matrix[1][0]      ))
  )
  __lowercase							  = (d(matrix[0][0]      ) * d(matrix[1][1]      )) - (
      d(matrix[0][1]      ) * d(matrix[1][0]      )
  )

  # Transpose the cofactor matrix (Adjoint matrix)
  __lowercase							  = array(A__      )
  for i in range(3      ):
   for j in range(3      ):
    __lowercase							  = cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
  __lowercase							  = array(A__      )
  for i in range(3      ):
   for j in range(3      ):
    inverse_matrix[i][j] /= d(A__      )

        # Calculate the inverse of the matrix
  return [[float(d(A__      )      ) or 0.0 for n in row] for row in inverse_matrix]
 raise ValueError('''Please provide a matrix of size 2x2 or 3x3.'''      )

