'''simple docstring'''




import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  int						=						""
      __UpperCamelCase:  str						=						(
          None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
      )
      __UpperCamelCase:  str						=						None  # compression type in fsspec. ex: "gzip"
      __UpperCamelCase:  str						=						None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz




      def __init__(       self						:				Union[str, Any]						,					A						:				str = ""						,					A						:				Optional[str] = None						,					A						:				Optional[dict] = None						,					**A						:				Dict       ):
             super().__init__(self						,					**A       )
             # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
             _UpperCAmelCase     :  List[str]							      =    fsspec.open(
                 A						,					mode="rb"						,					protocol=A						,					compression=self.compression						,					client_kwargs={
                     "requote_redirect_url": False,  # see https://github.com/huggingface/datasets/pull/5459
                     "trust_env": True,  # Enable reading proxy env variables.
                     **(target_options or {}).pop("client_kwargs"						,					{}       ),  # To avoid issues if it was already passed.
                 }						,					**(target_options or {})						,					)
             _UpperCAmelCase     :  Dict							      =    os.path.basename(self.file.path.split("::"       )[0]       )
             _UpperCAmelCase     :  Dict							      =    (
                 self.compressed_name[: self.compressed_name.rindex("."       )]
                 if "." in self.compressed_name
                 else self.compressed_name
             )
             _UpperCAmelCase     :  Union[str, Any]							      =    None




      @classmethod
      def      _A	(       cls						:				Optional[int]						,					A						:				Union[str, Any]       ):
             # compressed file paths are always relative to the archive root
             return super()._strip_protocol(A       ).lstrip("/"       )




      def      _A	(       self						:				int       ):
             if self.dir_cache is None:
                    _UpperCAmelCase     :  int							      =    {**self.file.fs.info(self.file.path       ), "name": self.uncompressed_name}
                    _UpperCAmelCase     :  str							      =    {f["name"]: f}




      def      _A	(       self						:				Tuple						,					A						:				str       ):
             return self.file.open().read()





      def      _A	(       self						:				List[str]						,					A						:				str						,					A						:				str = "rb"						,					A						:				int=None						,					A						:				Optional[Any]=True						,					A						:				int=None						,					**A						:				Any						,					):
             _UpperCAmelCase     :  List[Any]							      =    self._strip_protocol(A       )
             if mode != "rb":
                    raise ValueError(F"""Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"""       )
             return self.file.open()

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  Union[str, Any]						=						"bz2"
      __UpperCamelCase:  Optional[int]						=						"bz2"
      __UpperCamelCase:  Union[str, Any]						=						".bz2"

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  Dict						=						"gzip"
      __UpperCamelCase:  str						=						"gzip"
      __UpperCamelCase:  int						=						".gz"

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  List[Any]						=						"lz4"
      __UpperCamelCase:  List[Any]						=						"lz4"
      __UpperCamelCase:  int						=						".lz4"

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  str						=						"xz"
      __UpperCamelCase:  Tuple						=						"xz"
      __UpperCamelCase:  str						=						".xz"

class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      __UpperCamelCase:  Any						=						"zstd"
      __UpperCamelCase:  Tuple						=						"zstd"
      __UpperCamelCase:  Tuple						=						".zst"




      def __init__(       self						:				Union[str, Any]						,					A						:				str						,					A						:				str = "rb"						,					A						:				Optional[str] = None						,					A						:				Optional[dict] = None						,					A						:				int = DEFAULT_BLOCK_SIZE						,					**A						:				List[str]						,					):
             super().__init__(
                 fo=A						,					mode=A						,					target_protocol=A						,					target_options=A						,					block_size=A						,					**A						,					)
             # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
             #
             # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
             #     out.close = close
             # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
             #
             # see https://github.com/intake/filesystem_spec/issues/725
             _UpperCAmelCase     :  List[str]							      =    self.file.__enter__

             class 	lowerCamelCase_	:
                   '''simple docstring'''

                   def __init__(       self						:				Optional[Any]						,					A						:				Any       ):
                          _UpperCAmelCase     :  Optional[Any]							      =    file_




                   def __enter__(       self						:				Tuple       ):
                          self._file.__enter__()
                          return self




                   def __exit__(       self						:				str						,					*A						:				Optional[Any]						,					**A						:				Optional[Any]       ):
                          self._file.__exit__(*A						,					**A       )




                   def __iter__(       self						:				int       ):
                          return iter(self._file       )




                   def      _A	(       self						:				Union[str, Any]       ):
                          return next(self._file       )





                   def __getattr__(       self						:				Union[str, Any]						,					A						:				Optional[int]       ):
                          return getattr(self._file						,					A       )

             def fixed_enter(*A						:				int						,					**A						:				Any       ):
                    return WrappedFile(_enter(*A						,					**A       )       )

             _UpperCAmelCase     :  Optional[Any]							      =    fixed_enter


'''simple docstring'''




__SCREAMING_SNAKE_CASE       :     Dict     =  8.3_1_4_4_6_2  # Unit - J mol-1 K-1

def 	UpperCamelCase_							(					_UpperCAmelCase  :      float			,	_UpperCAmelCase  :      float			,	_UpperCAmelCase  :      float    )    ->    float:


       """simple docstring"""







       if moles < 0 or kelvin < 0 or volume < 0:
              raise ValueError("Invalid inputs. Enter positive value."    )
       return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume

def 	UpperCamelCase_							(					_UpperCAmelCase  :      float			,	_UpperCAmelCase  :      float			,	_UpperCAmelCase  :      float    )    ->    float:


       """simple docstring"""







       if moles < 0 or kelvin < 0 or pressure < 0:
              raise ValueError("Invalid inputs. Enter positive value."    )
       return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


if __name__ == "__main__":
  from doctest import testmod

  testmod()

