response_model: Any = Default(None),
        status_code: Optional[int] = None,
        tags: Optional[list[Union[str, Enum]]] = None,
        dependencies: Optional[Sequence[Depends]] = None,
        summary: Optional[str] = None,
        description: Optional[str] = None,
        response_description: str = "Successful Response",
        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,

            }

            @Nonnull
            @Override
            public Optional<Path> getPath() {
                return Optional.ofNullable(path);
            }

            @Nonnull
            @Override
            public Optional<Source> getSource() {
                return Optional.ofNullable(source);
            }

            @Override

        return versionRange.isSelectedVersionKnown(this);
    }

    @Override
    public void setOptional(boolean optional) {
        this.optional = optional;
    }

    assertEquals(
        com.google.common.base.Optional.absent(),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    assertEquals(
        com.google.common.base.Optional.of("2"),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    // Test that the first generated instance for different cgcb.Optional<T> is always absent().

```

////

#### Использовать `Union` или `Optional` { #using-union-or-optional }

Если вы используете версию Python ниже 3.10, вот совет с моей весьма **субъективной** точки зрения:

* 🚨 Избегайте использования `Optional[SomeType]`
* Вместо этого ✨ **используйте `Union[SomeType, None]`** ✨.

    checkNotNull(valueComparator);
    return Comparator.<Optional<T>, @Nullable T>comparing(
        o -> orElseNull(o), Comparator.nullsLast(valueComparator));
  }

  // For discussion of why this exists, see the Android flavor.
  private static <T> @Nullable T orElseNull(Optional<T> optional) {
    return optional.orElse(null);
  }

  /**

     *
     * @param dir the directory to locate the pom for, never {@code null}
     * @return a {@code Source} pointing to the located pom or an empty {@code Optional} if none was found by this parser
     */
    @Nonnull
    Optional<Source> locate(@Nonnull Path dir);

    /**
     * Parse the model obtained previously by a previous call to {@link #locate(Path)}.
     *

import java.util.Arrays;
import java.util.Optional;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

/**
 * Tests for {@link DosError}.  Since {@link DosError} only contains
 * constants, the tests exercise the data and small helper logic in this
 * test class.
 */
public class DosErrorTest {
    private static Optional<Integer> findNtStatus(int dosErrorCode) {

        return AbstractValueGraph.this.outDegree(node);
      }
    };
  }

  @Override
  public Optional<V> edgeValue(N nodeU, N nodeV) {
    return Optional.ofNullable(edgeValueOrDefault(nodeU, nodeV, null));
  }

  @Override
  public Optional<V> edgeValue(EndpointPair<N> endpoints) {
    return Optional.ofNullable(edgeValueOrDefault(endpoints, null));
  }

  @Override

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultBuildResumptionAnalyzer.class);

    @Override
    public Optional<BuildResumptionData> determineBuildResumptionData(final MavenExecutionResult result) {
        if (!result.hasExceptions()) {
            return Optional.empty();
        }

        List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();

        boolean hasNoSuccess =