


import argparse
import os
import re

import packaging.version


UpperCamelCase								=	"""examples/"""
UpperCamelCase								=	{
    """examples""": (re.compile(r"""^check_min_version\(\"[^\"]+\"\)\s*$""", re.MULTILINE), """check_min_version(\"VERSION\")\n"""),
    """init""": (re.compile(r"""^__version__\s+=\s+\"([^\"]+)\"\s*$""", re.MULTILINE), """__version__ = \"VERSION\"\n"""),
    """setup""": (re.compile(r"""^(\s*)version\s*=\s*\"[^\"]+\",""", re.MULTILINE), r"""\1version=\"VERSION\","""),
    """doc""": (re.compile(r"""^(\s*)release\s*=\s*\"[^\"]+\"$""", re.MULTILINE), """release = \"VERSION\"\n"""),
}
UpperCamelCase								=	{
    """init""": """src/diffusers/__init__.py""",
    """setup""": """setup.py""",
}
UpperCamelCase								=	"""README.md"""


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
  with open(SCREAMING_SNAKE_CASE ,			'''r''' ,			encoding='''utf-8''' ,			newline='''\n'''       ) as f:
    A_      :				List[str]		     =					f.read()
  A_     ,       A_      :				Union[str, Any]		     =					REPLACE_PATTERNS[pattern]
  A_      :				Dict		     =					replace.replace('''VERSION''' ,			SCREAMING_SNAKE_CASE       )
  A_      :				List[Any]		     =					re_pattern.sub(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )
  with open(SCREAMING_SNAKE_CASE ,			'''w''' ,			encoding='''utf-8''' ,			newline='''\n'''       ) as f:
    f.write(SCREAMING_SNAKE_CASE       )


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE       ):
  for folder, directories, fnames in os.walk(SCREAMING_SNAKE_CASE       ):
    # Removing some of the folders with non-actively maintained examples from the walk
    if "research_projects" in directories:
      directories.remove('''research_projects'''       )
    if "legacy" in directories:
      directories.remove('''legacy'''       )
    for fname in fnames:
      if fname.endswith('''.py'''       ):
        update_version_in_file(os.path.join(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ) ,			SCREAMING_SNAKE_CASE ,			pattern='''examples'''       )


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE=False       ):
  for pattern, fname in REPLACE_FILES.items():
    update_version_in_file(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )
  if not patch:
    update_version_in_examples(SCREAMING_SNAKE_CASE       )


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Any		     =					'''🤗 Transformers currently provides the following architectures'''
  A_      :				Optional[Any]		     =					'''1. Want to contribute a new model?'''
  with open(SCREAMING_SNAKE_CASE ,			'''r''' ,			encoding='''utf-8''' ,			newline='''\n'''       ) as f:
    A_      :				Optional[int]		     =					f.readlines()

  # Find the start of the list.
  A_      :				Dict		     =					0
  while not lines[start_index].startswith(_start_prompt       ):
    start_index += 1
  start_index += 1

  A_      :				Any		     =					start_index
  # Update the lines in the model list.
  while not lines[index].startswith(_end_prompt       ):
    if lines[index].startswith('''1.'''       ):
      A_      :				int		     =					lines[index].replace(
          '''https://huggingface.co/docs/diffusers/main/model_doc''' ,			'''https://huggingface.co/docs/diffusers/model_doc''' ,			)
    index += 1

  with open(SCREAMING_SNAKE_CASE ,			'''w''' ,			encoding='''utf-8''' ,			newline='''\n'''       ) as f:
    f.writelines(SCREAMING_SNAKE_CASE       )


def   _SCREAMING_SNAKE_CASE	( ):
  with open(REPLACE_FILES['''init'''] ,			'''r'''       ) as f:
    A_      :				Optional[int]		     =					f.read()
  A_      :				Dict		     =					REPLACE_PATTERNS['''init'''][0].search(SCREAMING_SNAKE_CASE       ).groups()[0]
  return packaging.version.parse(SCREAMING_SNAKE_CASE       )


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE=False       ):
  A_      :				Optional[Any]		     =					get_version()
  if patch and default_version.is_devrelease:
    raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''       )
  if default_version.is_devrelease:
    A_      :				int		     =					default_version.base_version
  elif patch:
    A_      :				Any		     =					f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
  else:
    A_      :				Optional[int]		     =					f'''{default_version.major}.{default_version.minor + 1}.0'''

  # Now let's ask nicely if that's the right one.
  A_      :				List[str]		     =					input(f'''Which version are you releasing? [{default_version}]'''       )
  if len(SCREAMING_SNAKE_CASE       ) == 0:
    A_      :				str		     =					default_version

  print(f'''Updating version to {version}.'''       )
  global_version_update(SCREAMING_SNAKE_CASE ,			patch=SCREAMING_SNAKE_CASE       )


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Dict		     =					get_version()
  A_      :				Tuple		     =					f'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
  A_      :				str		     =					current_version.base_version

  # Check with the user we got that right.
  A_      :				Union[str, Any]		     =					input(f'''Which version are we developing now? [{dev_version}]'''       )
  if len(SCREAMING_SNAKE_CASE       ) == 0:
    A_      :				Tuple		     =					dev_version

  print(f'''Updating version to {version}.'''       )
  global_version_update(SCREAMING_SNAKE_CASE       )


#    print("Cleaning main README, don't forget to run `make fix-copies`.")
#    clean_main_ref_in_model_list()


if __name__ == "__main__":
     UpperCamelCase								=	argparse.ArgumentParser()
     parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""")
     parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""")
     UpperCamelCase								=	parser.parse_args()
     if not args.post_release:
          pre_release_work(patch=args.patch)
     elif args.patch:
          print("""Nothing to do after a patch :-)""")
     else:
          post_release_work()








import os
from typing import BinaryIO, Optional, Union

import numpy as np
import pyarrow.parquet as pq

from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config
from ..features.features import FeatureType, _visit
from ..formatting import query_table
from ..packaged_modules import _PACKAGED_DATASETS_MODULES
from ..packaged_modules.parquet.parquet import Parquet
from ..utils import logging
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE       ):
  A_      :				Any		     =					np.inf

  def set_batch_size(SCREAMING_SNAKE_CASE       ) -> None:
    nonlocal batch_size
    if isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
      A_      :				Tuple		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS       )
    elif isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
      A_      :				str		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS       )
    elif isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ) and feature.dtype == "binary":
      A_      :				Union[str, Any]		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS       )

  _visit(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )

  return None if batch_size is np.inf else batch_size






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       **_SCREAMING_SNAKE_CASE				,       )->str:




         '''simple docstring'''





         super().__init__(
             _SCREAMING_SNAKE_CASE				,       split=_SCREAMING_SNAKE_CASE				,       features=_SCREAMING_SNAKE_CASE				,       cache_dir=_SCREAMING_SNAKE_CASE				,       keep_in_memory=_SCREAMING_SNAKE_CASE				,       streaming=_SCREAMING_SNAKE_CASE				,       num_proc=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )
         A_      :				str		     =					path_or_paths if isinstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		) else {self.split: path_or_paths}
         A_      :				Optional[int]		     =					_PACKAGED_DATASETS_MODULES['''parquet'''][1]
         A_      :				Union[str, Any]		     =					Parquet(
             cache_dir=_SCREAMING_SNAKE_CASE				,       data_files=_SCREAMING_SNAKE_CASE				,       features=_SCREAMING_SNAKE_CASE				,       hash=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )







       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         if self.streaming:
           A_      :				List[str]		     =					self.builder.as_streaming_dataset(split=self.split		)
         # Build regular (map-style) dataset
         else:
           A_      :				List[str]		     =					None
           A_      :				List[str]		     =					None
           A_      :				List[Any]		     =					None
           A_      :				Dict		     =					None

           self.builder.download_and_prepare(
               download_config=_SCREAMING_SNAKE_CASE				,       download_mode=_SCREAMING_SNAKE_CASE				,       verification_mode=_SCREAMING_SNAKE_CASE				,       base_path=_SCREAMING_SNAKE_CASE				,       num_proc=self.num_proc				,       )
           A_      :				Union[str, Any]		     =					self.builder.as_dataset(
               split=self.split				,       verification_mode=_SCREAMING_SNAKE_CASE				,       in_memory=self.keep_in_memory		)
         return dataset






class   _lowerCamelCase :




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = None				,       **_SCREAMING_SNAKE_CASE				,       )->List[Any]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					dataset
         A_      :				Union[str, Any]		     =					path_or_buf
         A_      :				Any		     =					batch_size or get_writer_batch_size(dataset.features		)
         A_      :				Optional[int]		     =					parquet_writer_kwargs



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE

         if isinstance(self.path_or_buf				,       (str, bytes, os.PathLike)		):
           with open(self.path_or_buf				,       '''wb+'''		) as buffer:
             A_      :				str		     =					self._write(file_obj=_SCREAMING_SNAKE_CASE				,       batch_size=_SCREAMING_SNAKE_CASE				,       **self.parquet_writer_kwargs		)
         else:
           A_      :				Tuple		     =					self._write(file_obj=self.path_or_buf				,       batch_size=_SCREAMING_SNAKE_CASE				,       **self.parquet_writer_kwargs		)
         return written







       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)->int:




         '''simple docstring'''





         A_      :				List[Any]		     =					0
         A_      :				int		     =					parquet_writer_kwargs.pop('''path_or_buf'''				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					self.dataset.features.arrow_schema

         A_      :				List[str]		     =					pq.ParquetWriter(_SCREAMING_SNAKE_CASE				,       schema=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)

         for offset in logging.tqdm(
             range(0				,       len(self.dataset		)				,       _SCREAMING_SNAKE_CASE		)				,       unit='''ba'''				,       disable=not logging.is_progress_bar_enabled()				,       desc='''Creating parquet from Arrow format'''				,       ):
           A_      :				List[Any]		     =					query_table(
               table=self.dataset._data				,       key=slice(_SCREAMING_SNAKE_CASE				,       offset + batch_size		)				,       indices=self.dataset._indices if self.dataset._indices is not None else None				,       )
           writer.write_table(_SCREAMING_SNAKE_CASE		)
           written += batch.nbytes
         writer.close()
         return written




