




"""simple docstring"""







import json
import os
from pathlib import Path

import pytest

from datasets.download.download_config import DownloadConfig
from datasets.download.download_manager import DownloadManager
from datasets.utils.file_utils import hash_url_to_filename


__A   :  Dict					=      'http://www.mocksite.com/file1.txt'
__A   :  Any					=      '"text": ["foo", "foo"]'
__A   :  List[Any]					=      '6d8ce9aa78a471c7477201efbeabd3bb01ac2e7d100a6dc024ba1608361f90a8'




class       lowerCAmelCase__       :


				"""simple docstring"""





				__UpperCAmelCase :     Dict       =      200
				__UpperCAmelCase :     Optional[int]       =      {"Content-Length": "100"}
				__UpperCAmelCase :     Optional[Any]       =      {}



				def       snake_case    (     self					:	List[str]    ,   **lowercase__					:	Union[str, Any]						):
						return [bytes(lowercase__    ,   "utf-8"						)]





def 						snake_case__       (					*_lowerCamelCase,  **_lowerCamelCase				)			->int:






		"""simple docstring"""


		return MockResponse()

@pytest.mark.parametrize("urls_type",  [str, list, dict]				)
def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase				)			->Any:






		"""simple docstring"""


		import requests

		monkeypatch.setattr(_lowerCamelCase,  "request",  _lowerCamelCase				)

		__lowercase				:		Dict												=				URL
		if issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		Optional[Any]												=				url
		elif issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		str												=				[url]
		elif issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		List[str]												=				{"train": url}
		__lowercase				:		str												=				"dummy"
		__lowercase				:		str												=				"downloads"
		__lowercase				:		Any												=				tmp_path
		__lowercase				:		int												=				DownloadConfig(
		    cache_dir=os.path.join(_lowerCamelCase,  _lowerCamelCase				),  use_etag=_lowerCamelCase,  )
		__lowercase				:		Union[str, Any]												=				DownloadManager(dataset_name=_lowerCamelCase,  download_config=_lowerCamelCase				)
		__lowercase				:		List[str]												=				dl_manager.download(_lowerCamelCase				)
		__lowercase				:		Tuple												=				urls
		for downloaded_paths in [downloaded_paths]:
				if isinstance(_lowerCamelCase,  _lowerCamelCase				):
						__lowercase				:		Dict												=				[downloaded_paths]
						__lowercase				:		Any												=				[urls]
				elif isinstance(_lowerCamelCase,  _lowerCamelCase				):
						assert "train" in downloaded_paths.keys()
						__lowercase				:		int												=				downloaded_paths.values()
						__lowercase				:		Any												=				urls.values()
				assert downloaded_paths
				for downloaded_path, input_url in zip(_lowerCamelCase,  _lowerCamelCase				):
						assert downloaded_path == dl_manager.downloaded_paths[input_url]
						__lowercase				:		Any												=				Path(_lowerCamelCase				)
						__lowercase				:		Optional[int]												=				downloaded_path.parts
						assert parts[-1] == HASH
						assert parts[-2] == cache_subdir
						assert downloaded_path.exists()
						__lowercase				:		List[str]												=				downloaded_path.read_text()
						assert content == CONTENT
						__lowercase				:		Union[str, Any]												=				downloaded_path.with_suffix(".json"				)
						assert metadata_downloaded_path.exists()
						__lowercase				:		Union[str, Any]												=				json.loads(metadata_downloaded_path.read_text()				)
						assert metadata_content == {"url": URL, "etag": None}

@pytest.mark.parametrize("paths_type",  [str, list, dict]				)
def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase				)			->int:






		"""simple docstring"""


		__lowercase				:		Dict												=				str(_lowerCamelCase				)
		if issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		Optional[Any]												=				filename
		elif issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		List[str]												=				[filename]
		elif issubclass(_lowerCamelCase,  _lowerCamelCase				):
				__lowercase				:		str												=				{"train": filename}
		__lowercase				:		str												=				"dummy"
		__lowercase				:		str												=				xz_file.parent
		__lowercase				:		int												=				"extracted"
		__lowercase				:		Union[str, Any]												=				DownloadConfig(
		    cache_dir=_lowerCamelCase,  use_etag=_lowerCamelCase,  )
		__lowercase				:		Union[str, Any]												=				DownloadManager(dataset_name=_lowerCamelCase,  download_config=_lowerCamelCase				)
		__lowercase				:		Optional[int]												=				dl_manager.extract(_lowerCamelCase				)
		__lowercase				:		Any												=				paths
		for extracted_paths in [extracted_paths]:
				if isinstance(_lowerCamelCase,  _lowerCamelCase				):
						__lowercase				:		int												=				[extracted_paths]
						__lowercase				:		List[str]												=				[paths]
				elif isinstance(_lowerCamelCase,  _lowerCamelCase				):
						assert "train" in extracted_paths.keys()
						__lowercase				:		Tuple												=				extracted_paths.values()
						__lowercase				:		List[str]												=				paths.values()
				assert extracted_paths
				for extracted_path, input_path in zip(_lowerCamelCase,  _lowerCamelCase				):
						assert extracted_path == dl_manager.extracted_paths[input_path]
						__lowercase				:		Union[str, Any]												=				Path(_lowerCamelCase				)
						__lowercase				:		Optional[int]												=				extracted_path.parts
						assert parts[-1] == hash_url_to_filename(_lowerCamelCase,  etag=_lowerCamelCase				)
						assert parts[-2] == extracted_subdir
						assert extracted_path.exists()
						__lowercase				:		List[Any]												=				extracted_path.read_text()
						__lowercase				:		Any												=				text_file.read_text()
						assert extracted_file_content == expected_file_content

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->Tuple:






		"""simple docstring"""


		assert path.endswith(".jsonl"				)
		for num_items, line in enumerate(_lowerCamelCase,  start=1				):
				__lowercase				:		Tuple												=				json.loads(line.decode("utf-8"				)				)
				assert item.keys() == {"col_1", "col_2", "col_3"}
		assert num_items == 4

@pytest.mark.parametrize("archive_jsonl",  ["tar_jsonl_path", "zip_jsonl_path"]				)
def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->List[Any]:






		"""simple docstring"""


		__lowercase				:		List[Any]												=				request.getfixturevalue(_lowerCamelCase				)
		__lowercase				:		Union[str, Any]												=				DownloadManager()
		for num_jsonl, (path, file) in enumerate(dl_manager.iter_archive(_lowerCamelCase				),  start=1				):
				_test_jsonl(_lowerCamelCase,  _lowerCamelCase				)
		assert num_jsonl == 2

@pytest.mark.parametrize("archive_nested_jsonl",  ["tar_nested_jsonl_path", "zip_nested_jsonl_path"]				)
def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->Optional[Any]:






		"""simple docstring"""


		__lowercase				:		int												=				request.getfixturevalue(_lowerCamelCase				)
		__lowercase				:		str												=				DownloadManager()
		for num_tar, (path, file) in enumerate(dl_manager.iter_archive(_lowerCamelCase				),  start=1				):
				for num_jsonl, (subpath, subfile) in enumerate(dl_manager.iter_archive(_lowerCamelCase				),  start=1				):
						_test_jsonl(_lowerCamelCase,  _lowerCamelCase				)
		assert num_tar == 1
		assert num_jsonl == 2





def 						snake_case__       (					_lowerCamelCase				)			->Tuple:






		"""simple docstring"""


		__lowercase				:		Optional[Any]												=				DownloadManager()
		for num_file, file in enumerate(dl_manager.iter_files(_lowerCamelCase				),  start=1				):
				assert os.path.basename(_lowerCamelCase				) == ("test.txt" if num_file == 1 else "train.txt")
		assert num_file == 2






"""simple docstring"""







from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  )			->list[float]:






		"""simple docstring"""


		__lowercase						,__lowercase				:		Dict												=				coefficient_matrix.shape
		__lowercase						,__lowercase				:		Tuple												=				constant_matrix.shape

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

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

		if rowsa != rowsa:
				__lowercase				:		Optional[Any]												=				(
				    "Coefficient and constant matrices dimensions must be nxn and nx1 but "
				    F'received {rowsa}x{colsa} and {rowsa}x{colsa}'
				)
				raise ValueError(_lowerCamelCase				)

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

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

		__lowercase				:		NDArray[floataa]												=				np.concatenate(
		    (coefficient_matrix, constant_matrix),  axis=1				)

		__lowercase						,__lowercase				:		str												=				table.shape

		strictly_diagonally_dominant(_lowerCamelCase				)

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

		return [float(_lowerCamelCase				) for i in new_val]

def 						snake_case__       (					_lowerCamelCase				)			->bool:






		"""simple docstring"""


		__lowercase						,__lowercase				:		int												=				table.shape

		__lowercase				:		Optional[int]												=				True

		for i in range(0,  _lowerCamelCase				):
				__lowercase				:		Optional[int]												=				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()
