



import os
import sys
import unittest


SCREAMING_SNAKE_CASE_:Tuple             =						os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
SCREAMING_SNAKE_CASE_:List[Any]             =						os.path.join(git_repo_path, """src""", """diffusers""")






class SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






    def 			_lowerCAmelCase					(       self		):
        A :       int          =   find_backend("""    if not is_torch_available():"""		)
        self.assertEqual(lowerCamelCase__,		"""torch"""		)

        # backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
        # self.assertEqual(backend_with_underscore, "tensorflow_text")

        A :       Optional[int]          =   find_backend("""    if not (is_torch_available() and is_transformers_available()):"""		)
        self.assertEqual(lowerCamelCase__,		"""torch_and_transformers"""		)

        # double_backend_with_underscore = find_backend(
        #    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
        # )
        # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

        A :       Tuple          =   find_backend(
            """    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):"""		)
        self.assertEqual(lowerCamelCase__,		"""torch_and_transformers_and_onnx"""		)






    def 			_lowerCAmelCase					(       self		):
        A :       List[Any]          =   read_init()
        # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
        self.assertIn("""torch""",		lowerCamelCase__		)
        self.assertIn("""torch_and_transformers""",		lowerCamelCase__		)
        self.assertIn("""flax_and_transformers""",		lowerCamelCase__		)
        self.assertIn("""torch_and_transformers_and_onnx""",		lowerCamelCase__		)

        # Likewise, we can't assert on the exact content of a key
        self.assertIn("""UNet2DModel""",		objects["""torch"""]		)
        self.assertIn("""FlaxUNet2DConditionModel""",		objects["""flax"""]		)
        self.assertIn("""StableDiffusionPipeline""",		objects["""torch_and_transformers"""]		)
        self.assertIn("""FlaxStableDiffusionPipeline""",		objects["""flax_and_transformers"""]		)
        self.assertIn("""LMSDiscreteScheduler""",		objects["""torch_and_scipy"""]		)
        self.assertIn("""OnnxStableDiffusionPipeline""",		objects["""torch_and_transformers_and_onnx"""]		)






    def 			_lowerCAmelCase					(       self		):
        A :       Optional[Any]          =   create_dummy_object("""CONSTANT""",		"""'torch'"""		)
        self.assertEqual(lowerCamelCase__,		"""\nCONSTANT = None\n"""		)

        A :       List[str]          =   create_dummy_object("""function""",		"""'torch'"""		)
        self.assertEqual(
            lowerCamelCase__,		"""\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"""		)

        A :       Dict          =   """
class FakeClass(metaclass=DummyObject):
    _backends = 'torch'

    def __init__(self, *args, **kwargs):
        requires_backends(self, 'torch')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, 'torch')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, 'torch')
"""
        A :       List[str]          =   create_dummy_object("""FakeClass""",		"""'torch'"""		)
        self.assertEqual(lowerCamelCase__,		lowerCamelCase__		)






    def 			_lowerCAmelCase					(       self		):
        A :       Optional[int]          =   """# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, [\"torch\"])


class FakeClass(metaclass=DummyObject):
    _backends = [\"torch\"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, [\"torch\"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])
"""
        A :       Any          =   create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]}		)
        self.assertEqual(dummy_files["""torch"""],		lowerCamelCase__		)







from __future__ import annotations

from math import ceil, floor, sqrt




def 	__UpperCamelCase	(  _lowerCAmelCase = 200_0000		)       ->  int:



    """simple docstring"""






    A :       list[int]          =   [0]
    A :       int

    for idx in range(1      ,     ceil(sqrt(target * 2		) * 1.1		)		):
        triangle_numbers.append(triangle_numbers[-1] + idx		)

    # we want this to be as close as possible to target
    A :       int          =   0
    # the area corresponding to the grid that gives the product closest to target
    A :       int          =   0
    # an estimate of b, using the quadratic formula
    A :       float
    # the largest integer less than b_estimate
    A :       int
    # the largest integer less than b_estimate
    A :       int
    # the triangle number corresponding to b_floor
    A :       int
    # the triangle number corresponding to b_ceil
    A :       int

    for idx_a, triangle_a in enumerate(triangle_numbers[1:]      ,     1		):
        A :       Union[str, Any]          =   (-1 + sqrt(1 + 8 * target / triangle_a		)) / 2
        A :       List[Any]          =   floor(_lowerCAmelCase		)
        A :       Tuple          =   ceil(_lowerCAmelCase		)
        A :       int          =   triangle_numbers[b_floor]
        A :       Dict          =   triangle_numbers[b_ceil]

        if abs(target - triangle_b_first_guess * triangle_a		) < abs(
            target - best_product		):
            A :       Optional[int]          =   triangle_b_first_guess * triangle_a
            A :       Optional[int]          =   idx_a * b_floor

        if abs(target - triangle_b_second_guess * triangle_a		) < abs(
            target - best_product		):
            A :       Tuple          =   triangle_b_second_guess * triangle_a
            A :       Tuple          =   idx_a * b_ceil

    return area


if __name__ == "__main__":
     print(F"""{solution() = }""")


