*     return COMPARATOR.compare(this, that);
 *   }
 * }
 *
 * <p>With method references it is more succinct: {@code comparing(Foo::aString)} for example.
 *
 * <p>Using {@link Comparator} avoids certain types of bugs, for example when you meant to write
 * {@code .compare(a.foo, b.foo)} but you actually wrote {@code .compare(a.foo, a.foo)} or {@code

///

## Use `Annotated` in the type for the `q` parameter { #use-annotated-in-the-type-for-the-q-parameter }

Remember I told you before that `Annotated` can be used to add metadata to your parameters in the [Python Types Intro](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?

Now it's the time to use it with FastAPI. 🚀

We had this type annotation:

//// tab | Python 3.10+

```Python

        java.lang.annotation.Target target = CronExpression.class.getAnnotation(java.lang.annotation.Target.class);
        assertNotNull(target);

        java.lang.annotation.ElementType[] types = target.value();
        assertEquals(5, types.length);
    }

    // Test annotation retention policy
    public void test_annotationRetention() {

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Annotation types. This package is a part of the open-source <a
 * href="https://github.com/google/guava">Guava</a> library.
 */

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  4096;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '

## Wildcards { #wildcards }

It's also possible to declare the list as `"*"` (a "wildcard") to say that all are allowed.

But that will only allow certain types of communication, excluding everything that involves credentials: Cookies, Authorization headers like those used with Bearer Tokens, etc.

So, for everything to work correctly, it's better to specify explicitly the allowed origins.

# specific language governing permissions and limitations
# under the License.

name: Stale

on:
  schedule:
    - cron: '29 3 * * *'
  issue_comment:
    types: [ 'created' ]

jobs:
  stale:

/**
 * A class that implements {@code Comparable} without generics, such as those found in libraries
 * that support Java 1.4 and before. Our library needs to do the bare minimum to accommodate such
 * types, though their use may still require an explicit type parameter and/or warning suppression.
 *
 * @author Kevin Bourrillion
 */
@SuppressWarnings({"ComparableType", "rawtypes"}) // https://github.com/google/guava/issues/989

name: Check commits
on:
  merge_group:
  workflow_dispatch:
  pull_request:
    types:
     - opened
     - synchronize

permissions: {}

jobs:
  # See .github/workflows/CheckBadMerge.groovy for explanation
  check_bad_merge:
    if: github.event.pull_request.base.ref == 'master'
    permissions:
      contents: read
      issues: write
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code

import javax.security.auth.kerberos.KerberosKey;

import jcifs.pac.PACDecodingException;

/**
 * Abstract base class for Kerberos authorization data.
 * This class provides parsing capabilities for different types of Kerberos authorization data.
 */
public abstract class KerberosAuthData {

    /**
     * Default constructor for KerberosAuthData.
     */
    protected KerberosAuthData() {
        // Default constructor