

'''simple docstring'''







from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching
def  UpperCAmelCase__      ( )     ->     Dict:
       import os as original_os
       from os import path as original_path
       from os import rename as original_rename
       from os.path import dirname as original_dirname
       from os.path import join as original_join

       assert _test_patching.os is original_os
       assert _test_patching.path is original_path
       assert _test_patching.join is original_join

       assert _test_patching.renamed_os is original_os
       assert _test_patching.renamed_path is original_path
       assert _test_patching.renamed_join is original_join

       A_		   = """__test_patch_submodule_mock__"""
       with patch_submodule(_test_patching,    """os.path.join""",    UpperCAmelCase__			):
              # Every way to access os.path.join must be patched, and the rest must stay untouched

              # check os.path.join
              assert isinstance(_test_patching.os,    _PatchedModuleObj			)
              assert isinstance(_test_patching.os.path,    _PatchedModuleObj			)
              assert _test_patching.os.path.join is mock

              # check path.join
              assert isinstance(_test_patching.path,    _PatchedModuleObj			)
              assert _test_patching.path.join is mock

              # check join
              assert _test_patching.join is mock

              # check that the other attributes are untouched
              assert _test_patching.os.rename is original_rename
              assert _test_patching.path.dirname is original_dirname
              assert _test_patching.os.path.dirname is original_dirname

              # Even renamed modules or objects must be patched

              # check renamed_os.path.join
              assert isinstance(_test_patching.renamed_os,    _PatchedModuleObj			)
              assert isinstance(_test_patching.renamed_os.path,    _PatchedModuleObj			)
              assert _test_patching.renamed_os.path.join is mock

              # check renamed_path.join
              assert isinstance(_test_patching.renamed_path,    _PatchedModuleObj			)
              assert _test_patching.renamed_path.join is mock

              # check renamed_join
              assert _test_patching.renamed_join is mock

              # check that the other attributes are untouched
              assert _test_patching.renamed_os.rename is original_rename
              assert _test_patching.renamed_path.dirname is original_dirname
              assert _test_patching.renamed_os.path.dirname is original_dirname

       # check that everthing is back to normal when the patch is over

       assert _test_patching.os is original_os
       assert _test_patching.path is original_path
       assert _test_patching.join is original_join

       assert _test_patching.renamed_os is original_os
       assert _test_patching.renamed_path is original_path
       assert _test_patching.renamed_join is original_join
def  UpperCAmelCase__      ( )     ->     Union[str, Any]:
       assert _test_patching.open is open

       A_		   = """__test_patch_submodule_builtin_mock__"""
       # _test_patching has "open" in its globals
       assert _test_patching.open is open
       with patch_submodule(_test_patching,    """open""",    UpperCAmelCase__			):
              assert _test_patching.open is mock

       # check that everthing is back to normal when the patch is over

       assert _test_patching.open is open
def  UpperCAmelCase__      ( )     ->     List[Any]:
       # pandas.read_csv is not present in _test_patching
       A_		   = """__test_patch_submodule_missing_mock__"""
       with patch_submodule(_test_patching,    """pandas.read_csv""",    UpperCAmelCase__			):
              pass
def  UpperCAmelCase__      ( )     ->     Dict:
       # builtin should always be mocked even if they're not in the globals
       # in case they're loaded at one point
       A_		   = """__test_patch_submodule_missing_builtin_mock__"""
       # _test_patching doesn't have "len" in its globals
       assert getattr(_test_patching,    """len""",    UpperCAmelCase__			) is None
       with patch_submodule(_test_patching,    """len""",    UpperCAmelCase__			):
              assert _test_patching.len is mock
       assert _test_patching.len is len
def  UpperCAmelCase__      ( )     ->     Optional[int]:
       A_		   = """__test_patch_submodule_start_and_stop_mock__"""
       A_		   = patch_submodule(_test_patching,    """open""",    UpperCAmelCase__			)
       assert _test_patching.open is open
       patch.start()
       assert _test_patching.open is mock
       patch.stop()
       assert _test_patching.open is open
def  UpperCAmelCase__      ( )     ->     Optional[int]:
       from os import rename as original_rename
       from os.path import dirname as original_dirname
       from os.path import join as original_join

       A_		   = """__test_patch_submodule_successive_join__"""
       A_		   = """__test_patch_submodule_successive_dirname__"""
       A_		   = """__test_patch_submodule_successive_rename__"""
       assert _test_patching.os.path.join is original_join
       assert _test_patching.os.path.dirname is original_dirname
       assert _test_patching.os.rename is original_rename

       with patch_submodule(_test_patching,    """os.path.join""",    UpperCAmelCase__			):
              with patch_submodule(_test_patching,    """os.rename""",    UpperCAmelCase__			):
                     with patch_submodule(_test_patching,    """os.path.dirname""",    UpperCAmelCase__			):
                            assert _test_patching.os.path.join is mock_join
                            assert _test_patching.os.path.dirname is mock_dirname
                            assert _test_patching.os.rename is mock_rename

    # try another order
       with patch_submodule(_test_patching,    """os.rename""",    UpperCAmelCase__			):
              with patch_submodule(_test_patching,    """os.path.join""",    UpperCAmelCase__			):
                     with patch_submodule(_test_patching,    """os.path.dirname""",    UpperCAmelCase__			):
                            assert _test_patching.os.path.join is mock_join
                            assert _test_patching.os.path.dirname is mock_dirname
                            assert _test_patching.os.rename is mock_rename

       assert _test_patching.os.path.join is original_join
       assert _test_patching.os.path.dirname is original_dirname
       assert _test_patching.os.rename is original_rename







def  UpperCAmelCase__      ( )     ->     Dict:
       A_		   = """__test_patch_submodule_doesnt_exist_mock__"""
       with patch_submodule(_test_patching,    """__module_that_doesn_exist__.__attribute_that_doesn_exist__""",    UpperCAmelCase__			):
              pass
       with patch_submodule(_test_patching,    """os.__attribute_that_doesn_exist__""",    UpperCAmelCase__			):
              pass



'''simple docstring'''







from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    )     ->     list[float]:
       A_   ,     A_		   = coefficient_matrix.shape
       A_   ,     A_		   = constant_matrix.shape

       if rowsa != colsa:
              A_		   = F'''Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}'''
              raise ValueError(UpperCAmelCase__			)

       if colsa != 1:
              A_		   = F'''Constant matrix must be nx1 but received {rowsa}x{colsa}'''
              raise ValueError(UpperCAmelCase__			)

       if rowsa != rowsa:
              A_		   = (
                  """Coefficient and constant matrices dimensions must be nxn and nx1 but """
                  F'''received {rowsa}x{colsa} and {rowsa}x{colsa}'''
              )
              raise ValueError(UpperCAmelCase__			)

       if len(UpperCAmelCase__			) != rowsa:
              A_		   = (
                  """Number of initial values must be equal to number of rows in coefficient """
                  F'''matrix but received {len(UpperCAmelCase__			)} and {rowsa}'''
              )
              raise ValueError(UpperCAmelCase__			)

       if iterations <= 0:
              raise ValueError("""Iterations must be at least 1"""			)

       A_		   = np.concatenate(
           (coefficient_matrix, constant_matrix),    axis=1			)

       A_   ,     A_		   = table.shape

       strictly_diagonally_dominant(UpperCAmelCase__			)

       # Iterates the whole matrix for given number of times
       for _ in range(UpperCAmelCase__			):
              A_		   = []
              for row in range(UpperCAmelCase__			):
                     A_		   = 0
                     for col in range(UpperCAmelCase__			):
                            if col == row:
                                   A_		   = table[row][col]
                            elif col == cols - 1:
                                   A_		   = table[row][col]
                            else:
                                   temp += (-1) * table[row][col] * init_val[col]
                     A_		   = (temp + val) / denom
                     new_val.append(UpperCAmelCase__			)
              A_		   = new_val

       return [float(UpperCAmelCase__			) for i in new_val]
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     bool:
       A_   ,     A_		   = table.shape

       A_		   = True

       for i in range(0,    UpperCAmelCase__			):
              A_		   = 0
              for j in range(0,    cols - 1			):
                     if i == j:
                            continue
                     else:
                            total += table[i][j]

              if table[i][i] <= total:
                     raise ValueError("""Coefficient matrix is not strictly diagonally dominant"""			)

       return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
      import doctest

      doctest.testmod()
