public Source(String[] some) {}
                    public String foo(String[] bar) { return "some"; }
                }
            """,
            v2 = """
                import $nullableAnnotationName;
                public class Source {
                    public Source(@Nullable String[] some) {}
                    public String foo(@Nullable String[] bar) { return "some"; }
                }
            """

{* ../../docs_src/dependencies/tutorial008_an_py39.py hl[18:19,26:27] *}

The same way, you could have some dependencies with `yield` and some other dependencies with `return`, and have some of those depend on some of the others.

And you could have a single dependency that requires several other dependencies with `yield`, etc.

You can have any combinations of dependencies that you want.

      </searchConfiguration>

//// tab | Test

/// info
Some text
///

/// note
Some text
///

/// note | Technical details
Some text
///

/// check
Some text
///

/// tip
Some text
///

/// warning
Some text
///

/// danger
Some text
///

////

//// tab | Info

    response = client.post(
        "/items/", json={"name": "Foo", "price": "50.5", "description": "Some Foo"}
    )
    assert response.status_code == 200
    assert response.json() == {
        "name": "Foo",
        "price": 50.5,
        "description": "Some Foo",
        "tax": None,
    }


def test_post_with_str_float_description_tax(client: TestClient):
    response = client.post(

    def convertsPreElementsToProgramListingElements() {
        _ * classMetaData.rawCommentText >> ''' * <pre>this is some
 *
 * literal code</pre>
'''

        when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '''<programlisting language="java">this is some

literal code</programlisting>'''
    }

    def preElementCanContainReservedCharacters() {

newThing = objects.newInstance(NewThing.class)
newThing.convention("some-value")
```

This is acceptable for existing things:

```groovy
public interface ExistingThing {
    Property<String> getSomeProperty()
}

abstract class DefaultExistingThing implements ExistingThing {
    DefaultExistingThing() {
        getSomeProperty().convention("some-value")
    }
}

// in plugin

### Certificate Renewal { #certificate-renewal }

At some point in the future, each certificate would **expire** (about 3 months after acquiring it).

And then, there would be another program (in some cases it's another program, in some cases it could be the same TLS Termination Proxy) that would talk to Let's Encrypt, and renew the certificate(s).

In this case, it would be better to get **one extra server** and run some processes on it so that they all have **enough RAM and CPU time**.

Asynchronous code just means that the language 💬 has a way to tell the computer / program 🤖 that at some point in the code, it 🤖 will have to wait for *something else* to finish somewhere else. Let's say that *something else* is called "slow-file" 📝.

So, during that time, the computer can go and do some other work, while "slow-file" 📝 finishes.