





from abc import ABC, abstractmethod
from typing import List, Optional




class 			_a						(				_lowerCAmelCase    ):






				def __init__(			self		:   List[str]							)     ->				int:




										'''simple docstring'''



										self.test()






				def     snake_case     (			self		:   Tuple							)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   0
										_UpperCamelCase      : Union[str, Any]         =   False
										while not completed:
																if counter == 1:
																						self.reset()
																_UpperCamelCase      : Union[str, Any]         =   self.advance()
																if not self.does_advance(lowerCAmelCase__							):
																						raise Exception(
																						    '''Custom Constraint is not defined correctly. self.does_advance(self.advance()) must be true.'''							)

																_UpperCamelCase      : str         =   self.update(lowerCAmelCase__							)
																counter += 1

																if counter > 1_0_0_0_0:
																						raise Exception('''update() does not fulfill the constraint.'''							)

										if self.remaining() != 0:
																raise Exception('''Custom Constraint is not defined correctly.'''							)






				@abstractmethod
				def     snake_case     (			self		:   List[Any]							)     ->				Optional[Any]:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)






				@abstractmethod
				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   int							)     ->				Dict:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)






				@abstractmethod
				def     snake_case     (			self		:   Any,			lowerCAmelCase__		:   int							)     ->				Dict:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)






				@abstractmethod
				def     snake_case     (			self		:   Any							)     ->				Optional[Any]:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)






				@abstractmethod
				def     snake_case     (			self		:   List[Any]							)     ->				Optional[int]:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)






				@abstractmethod
				def     snake_case     (			self		:   Optional[int],			lowerCAmelCase__		:   Any=False							)     ->				Optional[Any]:




										'''simple docstring'''



										raise NotImplementedError(
										    f"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""							)




class 			_a						(				_lowerCAmelCase    ):






				def __init__(			self		:   Dict,			lowerCAmelCase__		:   List[int]							)     ->				List[Any]:




										'''simple docstring'''



										super(lowerCAmelCase__,			self							).__init__()

										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							) or len(lowerCAmelCase__							) == 0:
																raise ValueError(f"""`token_ids` has to be a non-empty list, but is {token_ids}."""							)
										if any((not isinstance(lowerCAmelCase__,			lowerCAmelCase__							) or token_id < 0) for token_id in token_ids							):
																raise ValueError(f"""Each list in `token_ids` has to be a list of positive integers, but is {token_ids}."""							)

										_UpperCamelCase      : List[Any]         =   token_ids

										_UpperCamelCase      : Optional[int]         =   len(self.token_ids							)
										_UpperCamelCase      : Union[str, Any]         =   -1  # the index of the currently fulfilled step
										_UpperCamelCase      : List[Any]         =   False






				def     snake_case     (			self		:   Optional[Any]							)     ->				Union[str, Any]:




										'''simple docstring'''



										if self.completed:
																return None
										return self.token_ids[self.fulfilled_idx + 1]






				def     snake_case     (			self		:   int,			lowerCAmelCase__		:   int							)     ->				Union[str, Any]:




										'''simple docstring'''



										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(f"""`token_id` has to be an `int`, but is {token_id} of type {type(lowerCAmelCase__							)}"""							)

										if self.completed:
																return False

										return token_id == self.token_ids[self.fulfilled_idx + 1]






				def     snake_case     (			self		:   List[Any],			lowerCAmelCase__		:   int							)     ->				List[Any]:




										'''simple docstring'''



										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(f"""`token_id` has to be an `int`, but is {token_id} of type {type(lowerCAmelCase__							)}"""							)

										_UpperCamelCase      : Dict         =   False
										_UpperCamelCase      : int         =   False
										_UpperCamelCase      : List[str]         =   False

										if self.does_advance(lowerCAmelCase__							):
																self.fulfilled_idx += 1
																_UpperCamelCase      : Optional[int]         =   True
																if self.fulfilled_idx == (self.seqlen - 1):
																						_UpperCamelCase      : Union[str, Any]         =   True
																_UpperCamelCase      : Dict         =   completed
										else:
																# failed to make progress.
																_UpperCamelCase      : List[Any]         =   True
																self.reset()
										return stepped, completed, reset






				def     snake_case     (			self		:   List[str]							)     ->				List[str]:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   False
										_UpperCamelCase      : Dict         =   0






				def     snake_case     (			self		:   Optional[int]							)     ->				Union[str, Any]:




										'''simple docstring'''



										return self.seqlen - (self.fulfilled_idx + 1)






				def     snake_case     (			self		:   List[Any],			lowerCAmelCase__		:   List[Any]=False							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : List[Any]         =   PhrasalConstraint(self.token_ids							)

										if stateful:
																_UpperCamelCase      : Any         =   self.seqlen
																_UpperCamelCase      : Tuple         =   self.fulfilled_idx
																_UpperCamelCase      : str         =   self.completed

										return new_constraint




class 			_a						:






				def __init__(			self		:   int,			lowerCAmelCase__		:   List[List[int]],			lowerCAmelCase__		:   List[Any]=True							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   max([len(lowerCAmelCase__							) for one in nested_token_ids]							)

										_UpperCamelCase      : Any         =   {}
										for token_ids in nested_token_ids:
																_UpperCamelCase      : str         =   root
																for tidx, token_id in enumerate(lowerCAmelCase__							):
																						if token_id not in level:
																												_UpperCamelCase      : Tuple         =   {}

																						_UpperCamelCase      : Tuple         =   level[token_id]

										if no_subsets and self.has_subsets(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(
																    '''Each list in `nested_token_ids` can\'t be a complete subset of another list, but is'''
																    f""" {nested_token_ids}."""							)

										_UpperCamelCase      : List[str]         =   root






				def     snake_case     (			self		:   Any,			lowerCAmelCase__		:   Tuple							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : str         =   self.trie

										for current_token in current_seq:
																_UpperCamelCase      : Optional[int]         =   start[current_token]

										_UpperCamelCase      : str         =   list(start.keys()							)

										return next_tokens






				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   Any							)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   self.next_tokens(lowerCAmelCase__							)

										return len(lowerCAmelCase__							) == 0






				def     snake_case     (			self		:   Dict,			lowerCAmelCase__		:   List[str]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   list(root.values()							)
										if len(lowerCAmelCase__							) == 0:
																return 1
										else:
																return sum([self.count_leaves(lowerCAmelCase__							) for nn in next_nodes]							)






				def     snake_case     (			self		:   Dict,			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   int							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   self.count_leaves(lowerCAmelCase__							)
										return len(lowerCAmelCase__							) != leaf_count




class 			_a						(				_lowerCAmelCase    ):






				def __init__(			self		:   Tuple,			lowerCAmelCase__		:   List[List[int]]							)     ->				Any:




										'''simple docstring'''



										super(lowerCAmelCase__,			self							).__init__()

										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							) or len(lowerCAmelCase__							) == 0:
																raise ValueError(f"""`nested_token_ids` has to be a non-empty list, but is {nested_token_ids}."""							)
										if any(not isinstance(lowerCAmelCase__,			lowerCAmelCase__							) for token_ids in nested_token_ids							):
																raise ValueError(f"""`nested_token_ids` has to be a list of lists, but is {nested_token_ids}."""							)
										if any(
										    any((not isinstance(lowerCAmelCase__,			lowerCAmelCase__							) or token_id < 0) for token_id in token_ids							)
										    for token_ids in nested_token_ids							):
																raise ValueError(
																    f"""Each list in `nested_token_ids` has to be a list of positive integers, but is {nested_token_ids}."""							)

										_UpperCamelCase      : int         =   DisjunctiveTrie(lowerCAmelCase__							)
										_UpperCamelCase      : str         =   nested_token_ids

										_UpperCamelCase      : Optional[int]         =   self.trie.max_height
										_UpperCamelCase      : Tuple         =   []
										_UpperCamelCase      : Optional[Any]         =   False






				def     snake_case     (			self		:   Any							)     ->				Tuple:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   self.trie.next_tokens(self.current_seq							)

										if len(lowerCAmelCase__							) == 0:
																return None
										else:
																return token_list






				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   int							)     ->				List[str]:




										'''simple docstring'''



										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(f"""`token_id` is supposed to be type `int`, but is {token_id} of type {type(lowerCAmelCase__							)}"""							)

										_UpperCamelCase      : str         =   self.trie.next_tokens(self.current_seq							)

										return token_id in next_tokens






				def     snake_case     (			self		:   List[str],			lowerCAmelCase__		:   int							)     ->				Tuple:




										'''simple docstring'''



										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(f"""`token_id` is supposed to be type `int`, but is {token_id} of type {type(lowerCAmelCase__							)}"""							)

										_UpperCamelCase      : List[Any]         =   False
										_UpperCamelCase      : List[Any]         =   False
										_UpperCamelCase      : Union[str, Any]         =   False

										if self.does_advance(lowerCAmelCase__							):
																self.current_seq.append(lowerCAmelCase__							)
																_UpperCamelCase      : Tuple         =   True
										else:
																_UpperCamelCase      : List[Any]         =   True
																self.reset()

										_UpperCamelCase      : List[Any]         =   self.trie.reached_leaf(self.current_seq							)
										_UpperCamelCase      : Union[str, Any]         =   completed

										return stepped, completed, reset






				def     snake_case     (			self		:   List[Any]							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   False
										_UpperCamelCase      : Optional[Any]         =   []






				def     snake_case     (			self		:   Optional[Any]							)     ->				Union[str, Any]:




										'''simple docstring'''



										if self.completed:
																# since this can be completed without reaching max height
																return 0
										else:
																return self.seqlen - len(self.current_seq							)






				def     snake_case     (			self		:   Tuple,			lowerCAmelCase__		:   Union[str, Any]=False							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : str         =   DisjunctiveConstraint(self.token_ids							)

										if stateful:
																_UpperCamelCase      : Optional[Any]         =   self.seqlen
																_UpperCamelCase      : Dict         =   self.current_seq
																_UpperCamelCase      : Tuple         =   self.completed

										return new_constraint




class 			_a						:






				def __init__(			self		:   Dict,			lowerCAmelCase__		:   List[Constraint]							)     ->				Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   constraints

										# max # of steps required to fulfill a given constraint
										_UpperCamelCase      : Optional[int]         =   max([c.seqlen for c in constraints]							)
										_UpperCamelCase      : Union[str, Any]         =   len(lowerCAmelCase__							)
										_UpperCamelCase      : int         =   False

										self.init_state()






				def     snake_case     (			self		:   Optional[Any]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   []
										_UpperCamelCase      : str         =   None
										_UpperCamelCase      : Union[str, Any]         =   [constraint.copy(stateful=lowerCAmelCase__							) for constraint in self.constraints]






				def     snake_case     (			self		:   Optional[int]							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   0
										if self.inprogress_constraint:
																# extra points for having a constraint mid-fulfilled
																add += self.max_seqlen - self.inprogress_constraint.remaining()

										return (len(self.complete_constraints							) * self.max_seqlen) + add






				def     snake_case     (			self		:   List[str]							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   []
										if self.inprogress_constraint is None:
																for constraint in self.pending_constraints:  # "pending" == "unfulfilled yet"
																						_UpperCamelCase      : Union[str, Any]         =   constraint.advance()
																						if isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																												token_list.append(lowerCAmelCase__							)
																						elif isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																												token_list.extend(lowerCAmelCase__							)
										else:
																_UpperCamelCase      : Optional[Any]         =   self.inprogress_constraint.advance()
																if isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																						token_list.append(lowerCAmelCase__							)
																elif isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																						token_list.extend(lowerCAmelCase__							)

										if len(lowerCAmelCase__							) == 0:
																return None
										else:
																return token_list






				def     snake_case     (			self		:   List[str],			lowerCAmelCase__		:   Optional[List[int]]							)     ->				Optional[Any]:




										'''simple docstring'''



										self.init_state()

										if token_ids is not None:
																for token in token_ids:
																						# completes or steps **one** constraint
																						_UpperCamelCase      : Tuple         =   self.add(lowerCAmelCase__							)

																						# the entire list of constraints are fulfilled
																						if self.completed:
																												break






				def     snake_case     (			self		:   List[str],			lowerCAmelCase__		:   int							)     ->				List[Any]:




										'''simple docstring'''



										if not isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(f"""`token_id` should be an `int`, but is `{token_id}`."""							)

										_UpperCamelCase      : Tuple         =   False, False

										if self.completed:
																_UpperCamelCase      : Dict         =   True
																_UpperCamelCase      : Any         =   False
																return complete, stepped

										if self.inprogress_constraint is not None:
																# In the middle of fulfilling a constraint. If the `token_id` *does* makes an incremental progress to current
																# job, simply update the state

																_UpperCamelCase      : Any         =   self.inprogress_constraint.update(lowerCAmelCase__							)
																if reset:
																						# 1. If the next token breaks the progress, then we must restart.
																						#     e.g. constraint = "I love pies" and sequence so far is "I love" but `token_id` == "books".

																						#     But that doesn't mean we self.init_state(), since we only reset the state for this particular
																						#     constraint, not the full list of constraints.

																						self.pending_constraints.append(self.inprogress_constraint.copy(stateful=lowerCAmelCase__							)							)
																						_UpperCamelCase      : Union[str, Any]         =   None

																if complete:
																						# 2. If the next token completes the constraint, move it to completed list, set
																						#     inprogress to None. If there are no pending constraints either, then this full list of constraints
																						#     is complete.

																						self.complete_constraints.append(self.inprogress_constraint							)
																						_UpperCamelCase      : Dict         =   None

																						if len(self.pending_constraints							) == 0:
																												# we're done!
																												_UpperCamelCase      : Optional[int]         =   True

										else:
																# Not in the middle of fulfilling a constraint. So does this `token_id` helps us step towards any of our list
																# of constraints?

																for cidx, pending_constraint in enumerate(self.pending_constraints							):
																						if pending_constraint.does_advance(lowerCAmelCase__							):
																												_UpperCamelCase      : List[Any]         =   pending_constraint.update(lowerCAmelCase__							)

																												if not stepped:
																																		raise Exception(
																																		    '''`constraint.update(token_id)` is not yielding incremental progress, '''
																																		    '''even though `constraint.does_advance(token_id)` is true.'''							)

																												if complete:
																																		self.complete_constraints.append(lowerCAmelCase__							)
																																		_UpperCamelCase      : Dict         =   None

																												if not complete and stepped:
																																		_UpperCamelCase      : Union[str, Any]         =   pending_constraint

																												if complete or stepped:
																																		# If we made any progress at all, then it's at least not a "pending constraint".

																																		_UpperCamelCase      : str         =   (
																																		    self.pending_constraints[:cidx] + self.pending_constraints[cidx + 1 :]
																																		)

																																		if len(self.pending_constraints							) == 0 and self.inprogress_constraint is None:
																																								# If there's no longer any pending after this and no inprogress either, then we must be
																																								# complete.

																																								_UpperCamelCase      : int         =   True

																																		break  # prevent accidentally stepping through multiple constraints with just one token.

										return complete, stepped






				def     snake_case     (			self		:   int,			lowerCAmelCase__		:   List[Any]=True							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   ConstraintListState(self.constraints							)  # we actually never though self.constraints objects
										# throughout this process. So it's at initialization state.

										if stateful:
																_UpperCamelCase      : List[str]         =   [
																    constraint.copy(stateful=lowerCAmelCase__							) for constraint in self.complete_constraints
																]
																if self.inprogress_constraint is not None:
																						_UpperCamelCase      : Optional[int]         =   self.inprogress_constraint.copy(stateful=lowerCAmelCase__							)
																_UpperCamelCase      : str         =   [constraint.copy() for constraint in self.pending_constraints]

										return new_state










"""simple docstring"""




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/transformers/__init__.py""",
    """setup""": """setup.py""",
}
UpperCamelCase_									="""README.md"""





def 	a_    (							_lowercase	,						_lowercase	,						_lowercase       ):
						with open(_lowercase	,						'''r'''	,						encoding='''utf-8'''	,						newline='''\n'''       ) as f:
												_UpperCamelCase      : Tuple         =   f.read()
						_UpperCamelCase       ,							_UpperCamelCase      : List[Any]         =   REPLACE_PATTERNS[pattern]
						_UpperCamelCase      : Optional[Any]         =   replace.replace('''VERSION'''	,						_lowercase       )
						_UpperCamelCase      : List[Any]         =   re_pattern.sub(_lowercase	,						_lowercase       )
						with open(_lowercase	,						'''w'''	,						encoding='''utf-8'''	,						newline='''\n'''       ) as f:
												f.write(_lowercase       )





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





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





def 	a_    (							):
						_UpperCamelCase      : Any         =   '''🤗 Transformers currently provides the following architectures'''
						_UpperCamelCase      : List[str]         =   '''1. Want to contribute a new model?'''
						with open(_lowercase	,						'''r'''	,						encoding='''utf-8'''	,						newline='''\n'''       ) as f:
												_UpperCamelCase      : List[Any]         =   f.readlines()

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

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

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





def 	a_    (							):
						with open(REPLACE_FILES['''init''']	,						'''r'''       ) as f:
												_UpperCamelCase      : List[Any]         =   f.read()
						_UpperCamelCase      : List[Any]         =   REPLACE_PATTERNS['''init'''][0].search(_lowercase       ).groups()[0]
						return packaging.version.parse(_lowercase       )





def 	a_    (							_lowercase=False       ):
						_UpperCamelCase      : Union[str, 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:
												_UpperCamelCase      : List[str]         =   default_version.base_version
						elif patch:
												_UpperCamelCase      : Union[str, Any]         =   F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
						else:
												_UpperCamelCase      : str         =   F"""{default_version.major}.{default_version.minor + 1}.0"""

						# Now let's ask nicely if that's the right one.
						_UpperCamelCase      : Optional[int]         =   input(F"""Which version are you releasing? [{default_version}]"""       )
						if len(_lowercase       ) == 0:
												_UpperCamelCase      : str         =   default_version

						print(F"""Updating version to {version}."""       )
						global_version_update(_lowercase	,						patch=_lowercase       )
						if not patch:
												print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''       )
												clean_main_ref_in_model_list()





def 	a_    (							):
						_UpperCamelCase      : Any         =   get_version()
						_UpperCamelCase      : Dict         =   F"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
						_UpperCamelCase      : Union[str, Any]         =   current_version.base_version

						# Check with the user we got that right.
						_UpperCamelCase      : int         =   input(F"""Which version are we developing now? [{dev_version}]"""       )
						if len(_lowercase       ) == 0:
												_UpperCamelCase      : List[str]         =   dev_version

						print(F"""Updating version to {version}."""       )
						global_version_update(_lowercase       )
						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()



