


'''simple docstring'''

from math import asin, atan, cos, radians, sin, sqrt, tan

a_						:       Optional[int]      			=				6378137.0
a_						:       Union[str, Any]      			=				6356752.314245
a_						:       Dict      			=				6378137





def __snake_case      (   UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		float	):
 lowerCamelCase_  				=						(AXIS_A - AXIS_B) / AXIS_A
 lowerCamelCase_  				=						atan((1 - flattening) * tan(radians(UpperCAmelCase_	)	)	)
 lowerCamelCase_  				=						atan((1 - flattening) * tan(radians(UpperCAmelCase_	)	)	)
 lowerCamelCase_  				=						radians(UpperCAmelCase_	)
 lowerCamelCase_  				=						radians(UpperCAmelCase_	)
 # Equation
 lowerCamelCase_  				=						sin((phi_a - phi_a) / 2	)
 lowerCamelCase_  				=						sin((lambda_a - lambda_a) / 2	)
 # Square both values
 sin_sq_phi *= sin_sq_phi
 sin_sq_lambda *= sin_sq_lambda
 lowerCamelCase_  				=						sqrt(sin_sq_phi + (cos(UpperCAmelCase_	) * cos(UpperCAmelCase_	) * sin_sq_lambda)	)
 return 2 * RADIUS * asin(UpperCAmelCase_	)


if __name__ == "__main__":
     import doctest

     doctest.testmod()







'''simple docstring'''

import argparse
import glob
import importlib.util
import os
import re

import black
from doc_builder.style_doc import style_docstrings_in_code


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
a_						:       str      			=				"""src/diffusers"""
a_						:       int      			=				"""."""


# This is to make sure the diffusers module imported is the one in the repo.
a_						:       int      			=				importlib.util.spec_from_file_location(
    """diffusers""",
    os.path.join(DIFFUSERS_PATH, """__init__.py"""),
    submodule_search_locations=[DIFFUSERS_PATH],
)
a_						:       List[Any]      			=				spec.loader.load_module()





def __snake_case      (   UpperCAmelCase_		:		Any      ,       UpperCAmelCase_		:		str	):
 return line.startswith(UpperCAmelCase_	) or len(UpperCAmelCase_	) <= 1 or re.search(r"^\s*\)(\s*->.*:|:)\s*$"      ,       UpperCAmelCase_	) is not None





def __snake_case      (   UpperCAmelCase_		:		List[Any]	):
 lowerCamelCase_  				=						object_name.split("."	)
 lowerCamelCase_  				=						0

 # First let's find the module where our object lives.
 lowerCamelCase_  				=						parts[i]
 while i < len(UpperCAmelCase_	) and not os.path.isfile(os.path.join(UpperCAmelCase_      ,       F'''{module}.py'''	)	):
  i += 1
  if i < len(UpperCAmelCase_	):
   lowerCamelCase_  				=						os.path.join(UpperCAmelCase_      ,       parts[i]	)
 if i >= len(UpperCAmelCase_	):
  raise ValueError(F'''`object_name` should begin with the name of a module of diffusers but got {object_name}.'''	)

 with open(os.path.join(UpperCAmelCase_      ,       F'''{module}.py'''	)      ,       "r"      ,       encoding="utf-8"      ,       newline="\n"	) as f:
  lowerCamelCase_  				=						f.readlines()

 # Now let's find the class / func in the code!
 lowerCamelCase_  				=						""
 lowerCamelCase_  				=						0
 for name in parts[i + 1 :]:
  while (
      line_index < len(UpperCAmelCase_	) and re.search(rF'''^{indent}(class|def)\s+{name}(\(|\:)'''      ,       lines[line_index]	) is None
  ):
   line_index += 1
  indent += "    "
  line_index += 1

 if line_index >= len(UpperCAmelCase_	):
  raise ValueError(F''' {object_name} does not match any function or class in {module}.'''	)

 # We found the beginning of the class / func, now let's find the end (when the indent diminishes).
 lowerCamelCase_  				=						line_index
 while line_index < len(UpperCAmelCase_	) and _should_continue(lines[line_index]      ,       UpperCAmelCase_	):
  line_index += 1
 # Clean up empty lines at the end (if any).
 while len(lines[line_index - 1]	) <= 1:
  line_index -= 1

 lowerCamelCase_  				=						lines[start_index:line_index]
 return "".join(UpperCAmelCase_	)


a_						:       Optional[Any]      			=				re.compile(R"""^(\s*)#\s*Copied from\s+diffusers\.(\S+\.\S+)\s*($|\S.*$)""")
a_						:       Optional[int]      			=				re.compile(R"""^\s*(\S+)->(\S+)(\s+.*|$)""")
a_						:       List[str]      			=				re.compile(R"""<FILL\s+[^>]*>""")





def __snake_case      (   UpperCAmelCase_		:		Optional[int]	):
 lowerCamelCase_  				=						code.split("\n"	)
 lowerCamelCase_  				=						0
 while idx < len(UpperCAmelCase_	) and len(lines[idx]	) == 0:
  idx += 1
 if idx < len(UpperCAmelCase_	):
  return re.search(r"^(\s*)\S"      ,       lines[idx]	).groups()[0]
 return ""





def __snake_case      (   UpperCAmelCase_		:		Union[str, Any]	):
 lowerCamelCase_  				=						len(get_indent(UpperCAmelCase_	)	) > 0
 if has_indent:
  lowerCamelCase_  				=						F'''class Bla:\n{code}'''
 lowerCamelCase_  				=						black.Mode(target_versions={black.TargetVersion.PYaa}      ,       line_length=119      ,       preview=UpperCAmelCase_	)
 lowerCamelCase_  				=						black.format_str(UpperCAmelCase_      ,       mode=UpperCAmelCase_	)
 lowerCamelCase_				,lowerCamelCase_  				=						style_docstrings_in_code(UpperCAmelCase_	)
 return result[len("class Bla:\n"	) :] if has_indent else result





def __snake_case      (   UpperCAmelCase_		:		Tuple      ,       UpperCAmelCase_		:		Tuple=False	):
 with open(UpperCAmelCase_      ,       "r"      ,       encoding="utf-8"      ,       newline="\n"	) as f:
  lowerCamelCase_  				=						f.readlines()
 lowerCamelCase_  				=						[]
 lowerCamelCase_  				=						0
 # Not a for loop cause `lines` is going to change (if `overwrite=True`).
 while line_index < len(UpperCAmelCase_	):
  lowerCamelCase_  				=						_re_copy_warning.search(lines[line_index]	)
  if search is None:
   line_index += 1
   continue

  # There is some copied code here, let's retrieve the original.
  lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_  				=						search.groups()
  lowerCamelCase_  				=						find_code_in_diffusers(UpperCAmelCase_	)
  lowerCamelCase_  				=						get_indent(UpperCAmelCase_	)

  lowerCamelCase_  				=						line_index + 1 if indent == theoretical_indent else line_index + 2
  lowerCamelCase_  				=						theoretical_indent
  lowerCamelCase_  				=						start_index

  # Loop to check the observed code, stop when indentation diminishes or if we see a End copy comment.
  lowerCamelCase_  				=						True
  while line_index < len(UpperCAmelCase_	) and should_continue:
   line_index += 1
   if line_index >= len(UpperCAmelCase_	):
    break
   lowerCamelCase_  				=						lines[line_index]
   lowerCamelCase_  				=						_should_continue(UpperCAmelCase_      ,       UpperCAmelCase_	) and re.search(F'''^{indent}# End copy'''      ,       UpperCAmelCase_	) is None
  # Clean up empty lines at the end (if any).
  while len(lines[line_index - 1]	) <= 1:
   line_index -= 1

  lowerCamelCase_  				=						lines[start_index:line_index]
  lowerCamelCase_  				=						"".join(UpperCAmelCase_	)

  # Remove any nested `Copied from` comments to avoid circular copies
  lowerCamelCase_  				=						[line for line in theoretical_code.split("\n"	) if _re_copy_warning.search(UpperCAmelCase_	) is None]
  lowerCamelCase_  				=						"\n".join(UpperCAmelCase_	)

  # Before comparing, use the `replace_pattern` on the original code.
  if len(UpperCAmelCase_	) > 0:
   lowerCamelCase_  				=						replace_pattern.replace("with"      ,       ""	).split(","	)
   lowerCamelCase_  				=						[_re_replace_pattern.search(UpperCAmelCase_	) for p in patterns]
   for pattern in patterns:
    if pattern is None:
     continue
    lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_  				=						pattern.groups()
    lowerCamelCase_  				=						re.sub(UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_	)
    if option.strip() == "all-casing":
     lowerCamelCase_  				=						re.sub(obja.lower()      ,       obja.lower()      ,       UpperCAmelCase_	)
     lowerCamelCase_  				=						re.sub(obja.upper()      ,       obja.upper()      ,       UpperCAmelCase_	)

            # Blackify after replacement. To be able to do that, we need the header (class or function definition)
            # from the previous line
   lowerCamelCase_  				=						blackify(lines[start_index - 1] + theoretical_code	)
   lowerCamelCase_  				=						theoretical_code[len(lines[start_index - 1]	) :]

  # Test for a diff and act accordingly.
  if observed_code != theoretical_code:
   diffs.append([object_name, start_index]	)
   if overwrite:
    lowerCamelCase_  				=						lines[:start_index] + [theoretical_code] + lines[line_index:]
    lowerCamelCase_  				=						start_index + 1

 if overwrite and len(UpperCAmelCase_	) > 0:
  # Warn the user a file has been modified.
  print(F'''Detected changes, rewriting {filename}.'''	)
  with open(UpperCAmelCase_      ,       "w"      ,       encoding="utf-8"      ,       newline="\n"	) as f:
   f.writelines(UpperCAmelCase_	)
 return diffs





def __snake_case      (   UpperCAmelCase_		:		bool = False	):
 lowerCamelCase_  				=						glob.glob(os.path.join(UpperCAmelCase_      ,       "**/*.py"	)      ,       recursive=UpperCAmelCase_	)
 lowerCamelCase_  				=						[]
 for filename in all_files:
  lowerCamelCase_  				=						is_copy_consistent(UpperCAmelCase_      ,       UpperCAmelCase_	)
  diffs += [F'''- {filename}: copy does not match {d[0]} at line {d[1]}''' for d in new_diffs]
 if not overwrite and len(UpperCAmelCase_	) > 0:
  lowerCamelCase_  				=						"\n".join(UpperCAmelCase_	)
  raise Exception(
      "Found the following copy inconsistencies:\n"
      + diff
      + "\nRun `make fix-copies` or `python utils/check_copies.py --fix_and_overwrite` to fix them."	)


if __name__ == "__main__":
     a_						:       Tuple      			=				argparse.ArgumentParser()
     parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""")
     a_						:       Optional[int]      			=				parser.parse_args()

     check_copies(args.fix_and_overwrite)



