
"""simple docstring"""

import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


SCREAMING_SNAKE_CASE_            =    datasets.utils.logging.get_logger(__name__)
@dataclass
class   _UpperCAmelCase				(		datasets.BuilderConfig				):
      __SCREAMING_SNAKE_CASE :				int				   =						1_0_0_0_0
      __SCREAMING_SNAKE_CASE :				Optional[List[str]]				   =						None
      __SCREAMING_SNAKE_CASE :				Optional[datasets.Features]				   =						None

class   _UpperCAmelCase				(		datasets.ArrowBasedBuilder				):
      __SCREAMING_SNAKE_CASE :				List[Any]				   =						ParquetConfig




      def      a_   (				self				)    ->       List[Any]:
          return datasets.DatasetInfo(features=self.config.features				)




      def      a_   (				self ,							lowercase_				)    ->       Optional[Any]:
          if not self.config.data_files:
              raise ValueError(F"At least one data file must be specified, but got data_files={self.config.data_files}"				)
          UpperCAmelCase          =       dl_manager.download_and_extract(self.config.data_files				)
          if isinstance(lowercase_ ,							(str, list, tuple)				):
              UpperCAmelCase          =       data_files
              if isinstance(lowercase_ ,							lowercase_				):
                  UpperCAmelCase          =       [files]
              # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
              UpperCAmelCase          =       [dl_manager.iter_files(lowercase_				) for file in files]
              return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,							gen_kwargs={'files': files}				)]
          UpperCAmelCase          =       []
          for split_name, files in data_files.items():
              if isinstance(lowercase_ ,							lowercase_				):
                  UpperCAmelCase          =       [files]
              # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
              UpperCAmelCase          =       [dl_manager.iter_files(lowercase_				) for file in files]
              # Infer features is they are stoed in the arrow schema
              if self.info.features is None:
                  for file in itertools.chain.from_iterable(lowercase_				):
                      with open(lowercase_ ,							'rb'				) as f:
                          UpperCAmelCase          =       datasets.Features.from_arrow_schema(pq.read_schema(lowercase_				)				)
                      break
              splits.append(datasets.SplitGenerator(name=lowercase_ ,							gen_kwargs={'files': files}				)				)
          return splits




      def      a_   (				self ,							lowercase_				)    ->       pa.Table:
          if self.info.features is not None:
              # more expensive cast to support nested features with keys in a different order
              # allows str <-> int/float or str to Audio for example
              UpperCAmelCase          =       table_cast(lowercase_ ,							self.info.features.arrow_schema				)
          return pa_table




      def      a_   (				self ,							lowercase_				)    ->       List[str]:
          UpperCAmelCase          =       self.info.features.arrow_schema if self.info.features is not None else None
          if self.info.features is not None and self.config.columns is not None:
              if sorted(field.name for field in schema				) != sorted(self.config.columns				):
                  raise ValueError(
                      F"Tried to load parquet data with columns '{self.config.columns}' with mismatching features '{self.info.features}'"				)
          for file_idx, file in enumerate(itertools.chain.from_iterable(lowercase_				)				):
              with open(lowercase_ ,							'rb'				) as f:
                  UpperCAmelCase          =       pq.ParquetFile(lowercase_				)
                  try:
                      for batch_idx, record_batch in enumerate(
                          parquet_file.iter_batches(batch_size=self.config.batch_size ,							columns=self.config.columns				)				):
                          UpperCAmelCase          =       pa.Table.from_batches([record_batch]				)
                          # Uncomment for debugging (will print the Arrow table size and elements)
                          # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                          # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                          yield F"{file_idx}_{batch_idx}", self._cast_table(lowercase_				)
                  except ValueError as e:
                      logger.error(F"Failed to read file '{file}' with error {type(lowercase_				)}: {e}"				)
                      raise





"""simple docstring"""

def      lowercase__    (       lowerCAmelCase					:       str			)			->   bool:






    """simple docstring"""




    UpperCAmelCase          =       [int(lowerCAmelCase			) for i in ip_va_address.split('.'			) if i.isdigit()]
    return len(lowerCAmelCase			) == 4 and all(0 <= int(lowerCAmelCase			) <= 254 for octet in octets			)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE_            =    input().strip()
   SCREAMING_SNAKE_CASE_            =    '''valid''' if is_ip_va_address_valid(ip) else '''invalid'''
   print(F'{ip} is a {valid_or_invalid} IP v4 address.')



