from fastapi import Depends, FastAPI
from typing_extensions import Annotated

app = FastAPI()


class FixedContentQueryChecker:
    def __init__(self, fixed_content: str):
        self.fixed_content = fixed_content

    def __call__(self, q: str = ""):
        if q:
            return self.fixed_content in q
        return False


checker = FixedContentQueryChecker("bar")


@app.get("/query-checker/")

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

retract v1.0.0 // bad
retract v1.9.0 // self

-- .info --
{"Version":"v1.9.0"}

-- p.go --

        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
        self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
        for depends in self.dependencies[::-1]:
            self.dependant.dependencies.insert(
                0,
                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
            )

app = FastAPI()


fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


class CommonQueryParams:
    def __init__(self, q: str | None = None, skip: int = 0, limit: int = 100):
        self.q = q
        self.skip = skip
        self.limit = limit


@app.get("/items/")
async def read_items(commons: Annotated[Any, Depends(CommonQueryParams)]):
    response = {}
    if commons.q:

    @InterceptCalls
    @InterceptInherited
    @CallableKind.InstanceMethod
    public static String intercept_sayHello(@ParameterKind.Receiver InheritedMethodTestReceiver self) {
        return self.sayHello() + " from: " + self.getClass().getName().replace(self.getClass().getPackage().getName() + ".", "");
    }

class DataStructureModel(module.Module):
  """Model used for testing data structures in the C++ API."""

  def __init__(self):
    self.arr1 = [1.]
    self.const_arr = [constant_op.constant(1.)]
    self.var_arr = [variables.Variable(1.), variables.Variable(2.)]
    self.dict1 = {"a": 1.}
    self.var_dict = {"a": variables.Variable(1.), "b": variables.Variable(2.)}


class SimpleModel(module.Module):

Module example.com/retract/self/pseudo is a module that retracts its own
latest version, as well as an earlier version.

An unretracted pseudo-version is available.

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

go 1.15

retract v1.0.0-bad // bad
retract v1.9.0 // self

-- .info --

    # output shape: [-1, 1024]
    fc1 = gen_mnist_ops.new_fully_connected(reshape, self.weights['f3'],
                                            self.biases['b3'], 'RELU')
    # output shape: [-1, 10]
    return gen_mnist_ops.new_fully_connected(fc1, self.weights['f4'],
                                             self.biases['b4'])


def main(strategy):

@needs_pydanticv2
def test_read_with_orm_mode() -> None:
    class PersonBase(BaseModel):
        name: str
        lastname: str

    class Person(PersonBase):
        @property
        def full_name(self) -> str:
            return f"{self.name} {self.lastname}"

        model_config = ConfigDict(from_attributes=True)

    class PersonCreate(PersonBase):
        pass

    class PersonRead(PersonBase):
        full_name: str

      if short_package_name not in self.packages_for_skip:
        try:
          __import__(short_package_name)
        except ImportError:
          logging.exception("error importing %s", short_package_name)
          failed_packages.append(package_name)

    if failed_packages:
      self.fail(
          "Failed to import"
          f" {len(failed_packages)}/{len(self.api_packages_v2)} packages"