def var = factory.newDirectoryProperty()
        def task = Stub(Task)
        def owner = Stub(ModelObject)
        owner.taskThatOwnsThisObject >> task
        def action = Mock(Action)

        when:
        var.attachProducer(owner)
        def producer = var.producer

        then:
        producer.known

        when:

     *   </tr>
     *   <tr>
     *     <td>700</td>
     *     <td>rwx------</td>
     *     <td>read, write &amp; execute only for owner</td>
     *   </tr>
     *   <tr>
     *     <td>770</td>
     *     <td>rwxrwx---</td>
     *     <td>read, write &amp; execute for owner and group</td>
     *   </tr>
     *   <tr>
     *     <td>111</td>
     *     <td>--x--x--x</td>
     *     <td>execute</td>

data = {
    "plumbus": {"description": "Freshly pickled plumbus", "owner": "Morty"},
    "portal-gun": {"description": "Gun to create portals", "owner": "Rick"},
}


class OwnerError(Exception):
    pass


def get_username():
    try:
        yield "Rick"
    except OwnerError as e:
        raise HTTPException(status_code=400, detail=f"Owner error: {e}")


@app.get("/items/{item_id}")

    }

    private class DeclaredMemberScope(
        val allMemberScope: MemberScope,
        val owner: ClassDescriptor,
        val forDelegatedMembersOnly: Boolean
    ) : MemberScope {
        constructor(owner: ClassDescriptor, forDelegatedMembersOnly: Boolean = false) :
                this(owner.unsubstitutedMemberScope, owner, forDelegatedMembersOnly)

            if (opcode == INVOKESTATIC && visitINVOKESTATIC(owner, name, descriptor)) {
                return;
            }
            if (opcode == INVOKEVIRTUAL && visitINVOKEVIRTUAL(owner, name, descriptor)) {
                return;
            }
            if (opcode == INVOKESPECIAL && visitINVOKESPECIAL(owner, name, descriptor)) {
                return;
            }

    private final ResolvedArtifact publicView;

    public DefaultResolvableArtifact(@Nullable ModuleVersionIdentifier owner, IvyArtifactName artifact, ComponentArtifactIdentifier artifactId, TaskDependencyContainer builtBy, CalculatedValue<File> fileSource, CalculatedValueFactory calculatedValueFactory) {
        this.owner = owner;
        this.artifact = artifact;
        this.artifactId = artifactId;
        this.buildDependencies = builtBy;

        annotation: KaAnnotation,
        owner: KaAnnotated,
        annotationRenderer: KaAnnotationRenderer,
        printer: PrettyPrinter,
    )

    public object NONE : KaAnnotationArgumentsRenderer {
        override fun renderAnnotationArguments(
            analysisSession: KaSession,
            annotation: KaAnnotation,
            owner: KaAnnotated,
            annotationRenderer: KaAnnotationRenderer,

abstract class AbstractServiceMethod implements ServiceMethod {
    private final Method method;
    private final Class<?> owner;
    private final String name;
    private final Type[] parameterTypes;
    private final Type serviceType;

    AbstractServiceMethod(Method target) {
        this.method = target;
        this.owner = target.getDeclaringClass();
        this.name = target.getName();

    private final LeaseHolder parent;
    private Thread ownerThread;

    public DefaultLease(String displayName, ResourceLockCoordinationService coordinationService, ResourceLockContainer owner, LeaseHolder parent) {
        super(displayName, coordinationService, owner);
        this.parent = parent;
    }

    @Override
    protected boolean doIsLocked() {
        return ownerThread != null;
    }

    @Override

    int reservePort();

    /**
     * Pings the lock owner with the give port to start the lock releasing
     * process in the owner. May not ping the owner if:
     * - The owner was already pinged about the given lock before and the lock release is in progress
     * - The ping through the underlying socket failed
     *
     * @return true if the owner was pinged in this call
     */