


import argparse
import os
import re

import packaging.version


__snake_case									=		'''examples/'''
__snake_case									=		{
    '''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'''),
}
__snake_case									=		{
    '''init''': '''src/diffusers/__init__.py''',
    '''setup''': '''setup.py''',
}
__snake_case									=		'''README.md'''






def 						_A						(						_lowercase ,   _lowercase ,   _lowercase      ) ->      Tuple:


     """simple docstring"""


     with open(_UpperCAmelCase ,   'r' ,   encoding='utf-8' ,   newline='\n'      ) as f:
          __UpperCamelCase      =       f.read()
     __UpperCamelCase      =       REPLACE_PATTERNS[pattern]
     __UpperCamelCase      =       replace.replace('VERSION' ,   _UpperCAmelCase      )
     __UpperCamelCase      =       re_pattern.sub(_UpperCAmelCase ,   _UpperCAmelCase      )
     with open(_UpperCAmelCase ,   'w' ,   encoding='utf-8' ,   newline='\n'      ) as f:
          f.write(_UpperCAmelCase      )






def 						_A						(						_lowercase      ) ->      Tuple:


     """simple docstring"""


     for folder, directories, fnames in os.walk(_UpperCAmelCase      ):
          # 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(_UpperCAmelCase ,   _UpperCAmelCase      ) ,   _UpperCAmelCase ,   pattern='examples'      )






def 						_A						(						_lowercase ,   _lowercase=False      ) ->      List[Any]:


     """simple docstring"""


     for pattern, fname in REPLACE_FILES.items():
          update_version_in_file(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase      )
     if not patch:
          update_version_in_examples(_UpperCAmelCase      )






def 						_A						(						) ->      Any:


     """simple docstring"""


     __UpperCamelCase      =       """🤗 Transformers currently provides the following architectures"""
     __UpperCamelCase      =       """1. Want to contribute a new model?"""
     with open(_UpperCAmelCase ,   'r' ,   encoding='utf-8' ,   newline='\n'      ) as f:
          __UpperCamelCase      =       f.readlines()

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

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

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






def 						_A						(						) ->      List[Any]:


     """simple docstring"""


     with open(REPLACE_FILES['init'] ,   'r'      ) as f:
          __UpperCamelCase      =       f.read()
     __UpperCamelCase      =       REPLACE_PATTERNS["""init"""][0].search(_UpperCAmelCase      ).groups()[0]
     return packaging.version.parse(_UpperCAmelCase      )






def 						_A						(						_lowercase=False      ) ->      str:


     """simple docstring"""


     __UpperCamelCase      =       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:
          __UpperCamelCase      =       default_version.base_version
     elif patch:
          __UpperCamelCase      =       f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
     else:
          __UpperCamelCase      =       f'''{default_version.major}.{default_version.minor + 1}.0'''

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

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






def 						_A						(						) ->      Optional[int]:


     """simple docstring"""


     __UpperCamelCase      =       get_version()
     __UpperCamelCase      =       f'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
     __UpperCamelCase      =       current_version.base_version

     # Check with the user we got that right.
     __UpperCamelCase      =       input(f'''Which version are we developing now? [{dev_version}]'''      )
     if len(_UpperCAmelCase      ) == 0:
          __UpperCamelCase      =       dev_version

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


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


if __name__ == "__main__":
    __snake_case									=		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.''')
    __snake_case									=		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()






'''simple docstring'''







import contextlib
import os
import sqlitea

import pytest

from datasets import Dataset, Features, Value
from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Any    ,_UpperCAmelCase	:	str  )  ->			Dict:
       assert isinstance(_UpperCAmelCase    ,_UpperCAmelCase  )
       assert dataset.num_rows == 4
       assert dataset.num_columns == 3
       assert dataset.column_names == ["col_1", "col_2", "col_3"]
       for feature, expected_dtype in expected_features.items():
              assert dataset.features[feature].dtype == expected_dtype


@require_sqlalchemy
@pytest.mark.parametrize("""keep_in_memory"""    ,[False, True]  )
def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Optional[Any]    ,_UpperCAmelCase	:	Optional[int]    ,_UpperCAmelCase	:	Optional[int]    ,_UpperCAmelCase	:	str  )  ->			Optional[Any]:
       _a    : Any     					=tmp_path / """cache"""
       _a    : int     					={"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
       with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
              _a    : Tuple     					=SqlDatasetReader(
                  """dataset"""    ,"""sqlite:///""" + sqlite_path    ,cache_dir=_UpperCAmelCase    ,keep_in_memory=_UpperCAmelCase  ).read()
       _check_sql_dataset(_UpperCAmelCase    ,_UpperCAmelCase  )


@require_sqlalchemy
@pytest.mark.parametrize(
    """features"""    ,[
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]    ,)
def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	List[Any]    ,_UpperCAmelCase	:	Dict    ,_UpperCAmelCase	:	Optional[Any]    ,_UpperCAmelCase	:	int  )  ->			List[Any]:
       _a    : Union[str, Any]     					=tmp_path / """cache"""
       _a    : str     					={"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
       _a    : Optional[int]     					=features.copy() if features else default_expected_features
       _a    : Union[str, Any]     					=(
           Features({feature: Value(_UpperCAmelCase  ) for feature, dtype in features.items()}  ) if features is not None else None
       )
       _a    : Optional[Any]     					=SqlDatasetReader("""dataset"""    ,"""sqlite:///""" + sqlite_path    ,features=_UpperCAmelCase    ,cache_dir=_UpperCAmelCase  ).read()
       _check_sql_dataset(_UpperCAmelCase    ,_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Optional[Any]  )  ->			List[str]:
       with contextlib.closing(sqlitea.connect(_UpperCAmelCase  )  ) as con:
              _a    : Any     					=con.cursor()
              cur.execute("""SELECT * FROM dataset"""  )
              for row in cur:
                     yield row


@require_sqlalchemy
def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Dict    ,_UpperCAmelCase	:	Tuple    ,_UpperCAmelCase	:	List[str]  )  ->			Union[str, Any]:
       _a    : Union[str, Any]     					=tmp_path / """cache"""
       _a    : Union[str, Any]     					=os.path.join(_UpperCAmelCase    ,"""tmp.sql"""  )
       _a    : Tuple     					=SqlDatasetReader("""dataset"""    ,"""sqlite:///""" + sqlite_path    ,cache_dir=_UpperCAmelCase  ).read()
       SqlDatasetWriter(_UpperCAmelCase    ,"""dataset"""    ,"""sqlite:///""" + output_sqlite_path    ,num_proc=1  ).write()

       _a    : Tuple     					=iter_sql_file(_UpperCAmelCase  )
       _a    : List[Any]     					=iter_sql_file(_UpperCAmelCase  )

       for rowa, rowa in zip(_UpperCAmelCase    ,_UpperCAmelCase  ):
              assert rowa == rowa


@require_sqlalchemy
def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Optional[int]    ,_UpperCAmelCase	:	Any    ,_UpperCAmelCase	:	List[Any]  )  ->			Optional[int]:
       _a    : int     					=tmp_path / """cache"""
       _a    : Any     					=os.path.join(_UpperCAmelCase    ,"""tmp.sql"""  )
       _a    : Union[str, Any]     					=SqlDatasetReader("""dataset"""    ,"""sqlite:///""" + sqlite_path    ,cache_dir=_UpperCAmelCase  ).read()
       SqlDatasetWriter(_UpperCAmelCase    ,"""dataset"""    ,"""sqlite:///""" + output_sqlite_path    ,num_proc=2  ).write()

       _a    : List[Any]     					=iter_sql_file(_UpperCAmelCase  )
       _a    : str     					=iter_sql_file(_UpperCAmelCase  )

       for rowa, rowa in zip(_UpperCAmelCase    ,_UpperCAmelCase  ):
              assert rowa == rowa


@require_sqlalchemy
def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Union[str, Any]    ,_UpperCAmelCase	:	str    ,_UpperCAmelCase	:	List[Any]  )  ->			List[str]:
       _a    : List[str]     					=tmp_path / """cache"""
       _a    : Dict     					=os.path.join(_UpperCAmelCase    ,"""tmp.sql"""  )
       _a    : Optional[Any]     					=SqlDatasetReader("""dataset"""    ,"""sqlite:///""" + sqlite_path    ,cache_dir=_UpperCAmelCase  ).read()
       with pytest.raises(_UpperCAmelCase  ):
              SqlDatasetWriter(_UpperCAmelCase    ,"""dataset"""    ,"""sqlite:///""" + output_sqlite_path    ,num_proc=0  ).write()


