}

  def test_static_range_quantization_by_default(self):
    model = self.SimpleModel()

    saved_model_save.save(model, self._input_saved_model_path)

    # Use default QuantizationOptions.
    converted_model = quantize_model.quantize(
        self._input_saved_model_path,
        representative_dataset=self._simple_model_data_gen(),
    )

    self.assertIsNotNone(converted_model)
    self.assertCountEqual(

                public static int access_get_getMaxErrors(Task self) {
                    ${getDefaultDeprecation("Task", "maxErrors")}
                    return self.getMaxErrors().getOrElse(0);
                }

                public static void access_set_setMaxErrors(Task self, int arg0) {
                    ${getDefaultDeprecation("Task", "maxErrors")}
                    self.getMaxErrors().set(arg0);
                }
            }

        return self.modify(providerToDependency);
    }

    /**
     * Modifies a dependency.
     *
     * @param dependency dependency to modify
     * @return the modified dependency
     * @since 8.0
     */
    public static <D extends ModuleDependency> D call(DependencyModifier self, D dependency) {

    private final ClassLoaderSpec self;
    private final HierarchicalClassLoaderStructure parent;

    public HierarchicalClassLoaderStructure(ClassLoaderSpec self) {
        this(self, null);
    }

    public HierarchicalClassLoaderStructure(ClassLoaderSpec self, @Nullable HierarchicalClassLoaderStructure parent) {
        this.self = self;
        this.parent = parent;
    }

  namespace:
    var.query.new('namespace')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'namespace',
      'process_cpu_seconds_total{cluster=~"$%s"}' % self.cluster.name,
    )
    + var.query.withRefresh('time'),

  job:
    var.query.new('job')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'job',

                """
            ),
        ] = True,
    ):
        self.model = HTTPBaseModel(scheme="basic", description=description)
        self.scheme_name = scheme_name or self.__class__.__name__
        self.realm = realm
        self.auto_error = auto_error

    async def __call__(  # type: ignore
        self, request: Request
    ) -> Optional[HTTPBasicCredentials]:

class Depends:
    def __init__(
        self, dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
    ):
        self.dependency = dependency
        self.use_cache = use_cache

    def __repr__(self) -> str:
        attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
        cache = "" if self.use_cache else ", use_cache=False"
        return f"{self.__class__.__name__}({attr}{cache})"

                """
            ),
        ] = True,
    ):
        self.model: APIKey = APIKey(
            **{"in": APIKeyIn.query},  # type: ignore[arg-type]
            name=name,
            description=description,
        )
        self.scheme_name = scheme_name or self.__class__.__name__
        self.auto_error = auto_error

    async def __call__(self, request: Request) -> Optional[str]:

class Person:
    def __init__(self, name: str):
        self.name = name


class Pet:
    def __init__(self, owner: Person, name: str):
        self.owner = owner
        self.name = name


@dataclass
class Item:
    name: str
    count: int


class DictablePerson(Person):
    def __iter__(self):
        return ((k, v) for k, v in self.__dict__.items())


class DictablePet(Pet):

  def test_saved_model_to_stablehlo(self):
    with tempfile.TemporaryDirectory() as tempdir:
      path = build_savedmodel(tempdir)
      module_bytecode = tensorflow_to_stablehlo.savedmodel_to_stablehlo(
          input_path=path, input_arg_shapes_str='4'
      )
      with ir.Context() as ctx:
        stablehlo.register_dialect(ctx)
        module = ir.Module.parse(module_bytecode)