code: 
  
  
  '''simple docstring'''
  
  import posixpath
  from pathlib import Path
  from unittest.mock import patch
  
  import pytest
  from fsspec.implementations.local import AbstractFileSystem, LocalFileSystem, stringify_path
  from fsspec.registry import _registry as _fsspec_registry
  class _lowerCamelCase (		lowercase__							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		A_			:    Union[str, Any]   					=       """mock"""
  
  
  
  
  
  
  
  		def __init__(      self	:		List[Any]						,  *_A	:		Dict						,  _A	:		Optional[Any]						,  **_A	:		Optional[int]    )						->				Optional[Any]:
  			super().__init__()
  			__magic_name__ :					Dict  			=  LocalFileSystem(*_A						,  **_A    )
  			__magic_name__ :					List[Any]  			=  Path(_A    ).resolve().as_posix() + '/'
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple						,  _A	:		str						,  *_A	:		Tuple						,  **_A	:		Any    )						->				Tuple:
  			__magic_name__ :					List[str]  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.mkdir(_A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		List[Any]						,  _A	:		Union[str, Any]						,  *_A	:		str						,  **_A	:		int    )						->				Optional[int]:
  			__magic_name__ :					Any  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.makedirs(_A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Any						,  _A	:		int    )						->				int:
  			__magic_name__ :					List[str]  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.rmdir(_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		str						,  _A	:		Union[str, Any]						,  _A	:		Any=True						,  *_A	:		Optional[int]						,  **_A	:		Dict    )						->				Union[str, Any]:
  			__magic_name__ :					Any  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			__magic_name__ :					Dict  			=  self._fs.ls(_A						,  detail=_A						,  *_A						,  **_A    )
  			if detail:
  				return [{**info, "name": info["name"][len(self.local_root_dir    ) :]} for info in out]
  			else:
  				return [name[len(self.local_root_dir    ) :] for name in out]
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Optional[Any]						,  _A	:		Union[str, Any]						,  *_A	:		Optional[int]						,  **_A	:		str    )						->				int:
  			__magic_name__ :					Optional[int]  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			__magic_name__ :					int  			=  dict(self._fs.info(_A						,  *_A						,  **_A    )    )
  			__magic_name__ :					int  			=  out['name'][len(self.local_root_dir    ) :]
  			return out
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Optional[int]						,  _A	:		Union[str, Any]						,  _A	:		str						,  *_A	:		Union[str, Any]						,  **_A	:		Tuple    )						->				Dict:
  			__magic_name__ :					Any  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			__magic_name__ :					List[Any]  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.cp_file(_A						,  _A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Any						,  _A	:		Union[str, Any]						,  *_A	:		Optional[int]						,  **_A	:		int    )						->				str:
  			__magic_name__ :					Tuple  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.rm_file(_A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		int						,  _A	:		List[Any]						,  *_A	:		Any						,  **_A	:		str    )						->				List[Any]:
  			__magic_name__ :					Tuple  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.rm(_A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Optional[int]						,  _A	:		Tuple						,  *_A	:		Optional[Any]						,  **_A	:		Union[str, Any]    )						->				int:
  			__magic_name__ :					Optional[int]  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs._open(_A						,  *_A						,  **_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Optional[int]						,  _A	:		Union[str, Any]    )						->				Union[str, Any]:
  			__magic_name__ :					Any  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.created(_A    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple						,  _A	:		Dict    )						->				Optional[Any]:
  			__magic_name__ :					Tuple  			=  posixpath.join(self.local_root_dir						,  self._strip_protocol(_A    )    )
  			return self._fs.modified(_A    )
  
  
  
  
  
  
  
  		@classmethod
  		def      __lowerCAmelCase	(      cls	:		Optional[Any]						,  _A	:		Optional[int]    )						->				Tuple:
  			__magic_name__ :					Any  			=  stringify_path(_A    )
  			if path.startswith('mock://'    ):
  				__magic_name__ :					Optional[int]  			=  path[7:]
  			return path
  
  
  
  
  
  
  
  class _lowerCamelCase (		lowercase__							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		A_			:    Tuple   					=       """tmp"""
  		A_			:    Dict   					=       None
  
  
  
  
  
  
  
  		def __init__(      self	:		int						,  *_A	:		int						,  **_A	:		str    )						->				Any:
  			assert self.tmp_dir is not None, "TmpDirFileSystem.tmp_dir is not set"
  			super().__init__(*_A						,  **_A						,  local_root_dir=self.tmp_dir						,  auto_mkdir=_A    )
  
  
  
  
  
  
  
  		@classmethod
  		def      __lowerCAmelCase	(      cls	:		Optional[Any]						,  _A	:		str    )						->				Any:
  			__magic_name__ :					List[str]  			=  stringify_path(_A    )
  			if path.startswith('tmp://'    ):
  				__magic_name__ :					List[str]  			=  path[6:]
  			return path
  
  
  
  
  
  
  
  @pytest.fixture
  def lowerCamelCase    (    ):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	__magic_name__ :					Dict  			=  MockFileSystem
  	__magic_name__ :					Tuple  			=  TmpDirFileSystem
  	yield
  	del _fsspec_registry["mock"]
  	del _fsspec_registry["tmp"]
  
  
  
  
  
  @pytest.fixture
  def lowerCamelCase    (    lowerCAmelCase       :			Optional[int]	,	lowerCAmelCase       :			Tuple	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	__magic_name__ :					Optional[int]  			=  tmp_path_factory.mktemp('mockfs'	)
  	return MockFileSystem(local_root_dir=lowerCAmelCase	,	auto_mkdir=lowerCAmelCase	)
  
  
  
  
  
  @pytest.fixture
  def lowerCamelCase    (    lowerCAmelCase       :			Dict	,	lowerCAmelCase       :			Dict	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	__magic_name__ :					int  			=  tmp_path_factory.mktemp('tmpfs'	)
  	with patch.object(lowerCAmelCase	,	'tmp_dir'	,	lowerCAmelCase	):
  		yield TmpDirFileSystem()
style_context: 
  
  
  '''simple docstring'''
  
  import math
  
  
  
  
  
  def lowerCamelCase    (    lowerCAmelCase       :			int	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	if not isinstance(lowerCAmelCase	,	lowerCAmelCase	):
  		__magic_name__ :					str  			=  f'Input value of [number={number}] must be an integer'
  		raise TypeError(lowerCAmelCase	)
  	if number < 1:
  		__magic_name__ :					Tuple  			=  f'Input value of [number={number}] must be a positive integer'
  		raise ValueError(lowerCAmelCase	)
  	__magic_name__ :					Tuple  			=  [number]
  	while number != 1:
  		if number % 2 == 0:
  			__magic_name__ :					Optional[int]  			=  math.floor(math.sqrt(lowerCAmelCase	)	)
  		else:
  			__magic_name__ :					Union[str, Any]  			=  math.floor(
  			    math.sqrt(lowerCAmelCase	) * math.sqrt(lowerCAmelCase	) * math.sqrt(lowerCAmelCase	)	)
  		sequence.append(lowerCAmelCase	)
  	return sequence
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()