protected B usingGenerator(G subjectGenerator) {
    this.subjectGenerator = subjectGenerator;
    return self();
  }

  public G getSubjectGenerator() {
    return subjectGenerator;
  }

  @CanIgnoreReturnValue
  public B withSetUp(Runnable setUp) {
    this.setUp = setUp;
    return self();
  }

  public Runnable getSetUp() {
    return setUp;
  }

  @CanIgnoreReturnValue

  def save_exported_model(
      self,
      dst_saved_model_path: str,
      exported_model_serialized: bytes,
      src_saved_model_path: str,
      tags: set[str],
      serialized_signature_def_map: dict[str, bytes],
  ) -> Optional[bool]: ...
  # LINT.ThenChange()

  # LINT.IfChange(run_calibration)
  def run_calibration(
      self,
      saved_model_path: str,
      signature_keys: list[str],

    from pydantic import BaseModel, computed_field

    class Rectangle(BaseModel):
        width: int
        length: int

        @computed_field
        @property
        def area(self) -> int:
            return self.width * self.length

    @app.get("/")
    def read_root() -> Rectangle:
        return Rectangle(width=3, length=4)

    client = TestClient(app)
    return client


@needs_pydanticv2

/**
 * Describes a metadata about a dependency - direct dependency or dependency constraint - declared in a resolved component's metadata.
 *
 * @param <SELF> type extending this interface
 * @since 4.4
 */
public interface DependencyMetadata<SELF extends DependencyMetadata> {

    /**
     * Returns the group of the module that is targeted by this dependency or dependency constraint.

	sink = p
}

func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
	p.pairs[0] = p.pairs[1] // ERROR "ignoring self-assignment in p.pairs\[0\] = p.pairs\[1\]"
}

func paramArraySelfAssignUnsafeIndex(p *PairOfPairs) { // ERROR "leaking param content: p"
	// Function call inside index disables self-assignment case to trigger.
	p.pairs[zero()] = p.pairs[1]
	p.pairs[zero()+1] = p.pairs[1]
}

type PairOfPairs struct {

			}
		},
		func(j *apps.DeploymentSpec, c fuzz.Continue) {
			c.FuzzNoCustom(j) // fuzz self without calling this function again
			rhl := int32(c.Rand.Int31())
			pds := int32(c.Rand.Int31())
			j.RevisionHistoryLimit = &rhl
			j.ProgressDeadlineSeconds = &pds
		},
		func(j *apps.DeploymentStrategy, c fuzz.Continue) {
			c.FuzzNoCustom(j) // fuzz self without calling this function again
			// Ensure that strategyType is one of valid values.

Module example.com/retract/self/prerelease is a module that retracts its own
latest version and all other release version.

A pre-release version higher than the highest release version is still
available, and that should be matched by @latest.

-- .mod --
module example.com/retract/self/prerelease

go 1.15

-- .info --
{"Version":"v1.9.1-pre"}

-- p.go --

	// Config for creating self-signed root cert rotator.
	RotatorConfig *SelfSignedCARootCertRotatorConfig

	// OnRootCertUpdate is the cb which can only be called by self-signed root cert rotator
	OnRootCertUpdate func() error
}

type RootCertUpdateFunc func() error

// NewSelfSignedIstioCAOptions returns a new IstioCAOptions instance using self-signed certificate.

  @tf.function(input_signature=[
      tf.TensorSpec([1], tf.float32),
      tf.TensorSpec([2], tf.float32)
  ])
  def f0000_function_arity(self, x, y):
    return

  # Check index paths for lists.
  #
  # CHECK:      func {{@[a-zA-Z_0-9]+}}(
  # CHECK-SAME:   %arg0: tensor<f32> {tf._user_specified_name = "l", tf_saved_model.index_path = [0, 0]},

from typing import Any, List, Union

import peewee
from pydantic import BaseModel
from pydantic.utils import GetterDict


class PeeweeGetterDict(GetterDict):
    def get(self, key: Any, default: Any = None):
        res = getattr(self._obj, key, default)
        if isinstance(res, peewee.ModelSelect):
            return list(res)
        return res


class ItemBase(BaseModel):
    title: str
    description: Union[str, None] = None