import secrets
from random import shuffle
from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, punctuation




def       __lowerCAmelCase      (						A_   : int = 8					)    ->  str:
  __UpperCAmelCase						    =       ascii_letters + digits + punctuation
  return "".join(secrets.choice(_SCREAMING_SNAKE_CASE					) for _ in range(_SCREAMING_SNAKE_CASE					)					)




def       __lowerCAmelCase      (						A_   : Optional[int]						,	A_   : Optional[int]					)    ->  str:
  # Password Generator = full boot with random_number, random_letters, and
  # random_character FUNCTIONS
  # Put your code here...
  i -= len(_SCREAMING_SNAKE_CASE					)
  __UpperCAmelCase						    =       i // 3
  __UpperCAmelCase						    =       i % 3
  # chars = chars_incl + random_letters(ascii_letters, i / 3 + remainder) +
  #     random_number(digits, i / 3) + random_characters(punctuation, i / 3)
  __UpperCAmelCase						    =       (
      chars_incl
      + random(_SCREAMING_SNAKE_CASE						,	quotient + remainder					)
      + random(_SCREAMING_SNAKE_CASE						,	_SCREAMING_SNAKE_CASE					)
      + random(_SCREAMING_SNAKE_CASE						,	_SCREAMING_SNAKE_CASE					)
  )
  __UpperCAmelCase						    =       list(_SCREAMING_SNAKE_CASE					)
  shuffle(_SCREAMING_SNAKE_CASE					)
  return "".join(_SCREAMING_SNAKE_CASE					)

  # random is a generalised function for letters, characters and numbers




def       __lowerCAmelCase      (						A_   : Dict						,	A_   : Optional[Any]					)    ->  str:
  return "".join(secrets.choice(_SCREAMING_SNAKE_CASE					) for _ in range(_SCREAMING_SNAKE_CASE					)					)




def       __lowerCAmelCase      (						A_   : Dict						,	A_   : str					)    ->  Any:
  pass  # Put your code here...




def       __lowerCAmelCase      (						A_   : Optional[Any]						,	A_   : List[Any]					)    ->  List[str]:
  pass  # Put your code here...




def       __lowerCAmelCase      (						A_   : int						,	A_   : int					)    ->  Optional[int]:
  pass  # Put your code here...




def       __lowerCAmelCase      (						A_   : Dict						,	A_   : str = 8					)    ->  bool:

  if len(_SCREAMING_SNAKE_CASE					) < min_length:
    # Your Password must be at least 8 characters long
    return False

  __UpperCAmelCase						    =       any(char in ascii_uppercase for char in password					)
  __UpperCAmelCase						    =       any(char in ascii_lowercase for char in password					)
  __UpperCAmelCase						    =       any(char in digits for char in password					)
  __UpperCAmelCase						    =       any(char in punctuation for char in password					)

  return upper and lower and num and spec_char
  # Passwords should contain UPPERCASE, lowerase
  # numbers, and special characters




def       __lowerCAmelCase      (						)    ->  str:
  __UpperCAmelCase						    =       int(input("Please indicate the max length of your password: "					).strip()					)
  __UpperCAmelCase						    =       input(
      "Please indicate the characters that must be in your password: "					).strip()
  print("Password generated:"						,	password_generator(_SCREAMING_SNAKE_CASE					)					)
  print(
      "Alternative Password generated:"						,	alternative_password_generator(_SCREAMING_SNAKE_CASE						,	_SCREAMING_SNAKE_CASE					)						,	)
  print("[If you are thinking of using this passsword, You better save it.]"					)


if __name__ == "__main__":
       main()




def       __lowerCAmelCase      (						A_   : str					)    ->  bool:
  if not all(x.isalpha() for x in string					):
    raise ValueError("String must only contain alphabetic characters."					)

  __UpperCAmelCase						    =       sorted(string.lower()					)
  return len(A_					) == len(set(A_					)					)


if __name__ == "__main__":
       a_							=      input("""Enter a string """).strip()

       a_							=      is_isogram(input_str)
       print(F"{input_str} is {'an' if isogram else 'not an'} isogram.")



