}

  /**
   * @since 11.0
   */
  @Override
  /*
   * <? extends Object> is mostly the same as <?> to plain Java. But to nullness checkers, they
   * differ: <? extends Object> means "non-null types," while <?> means "all types."
   */
  public ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys) {
    return delegate().getAllPresent(keys);
  }

  /**
   * @since 11.0
   */
  @Override

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.survey.types

data class Client(
  val userAgent: String,
  val version: String,
  val platform: String? = null,
  val enabled: List<SuiteId> = listOf(),
  val supported: List<SuiteId> = listOf(),
) {

# Always check-out / check-in files with LF line endings.
* text=auto eol=lf

hack/verify-flags/known-flags.txt merge=union
test/test_owners.csv merge=union

**/zz_generated.*.go linguist-generated=true
**/types.generated.go linguist-generated=true
**/generated.pb.go linguist-generated=true
**/generated.proto
**/types_swagger_doc_generated.go linguist-generated=true
api/openapi-spec/*.json linguist-generated=true

from contextlib import AsyncExitStack

from starlette.types import ASGIApp, Receive, Scope, Send


# Used mainly to close files after the request is done, dependencies are closed
# in their own AsyncExitStack
class AsyncExitStackMiddleware:
    def __init__(
        self, app: ASGIApp, context_name: str = "fastapi_middleware_astack"
    ) -> None:
        self.app = app
        self.context_name = context_name

type Config struct {
	Enabled        bool     `json:"enabled"`
	AllowEncrypted bool     `json:"allow_encryption"`
	Extensions     []string `json:"extensions"`
	MimeTypes      []string `json:"mime-types"`
}

// Compression environment variables
const (
	Extensions     = "extensions"
	AllowEncrypted = "allow_encryption"
	MimeTypes      = "mime_types"

	EnvCompressState           = "MINIO_COMPRESSION_ENABLE"

    return containsKey(key) ? unfiltered.removeAll(key) : unmodifiableEmptyCollection();
  }

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  Collection<V> unmodifiableEmptyCollection() {
    if (unfiltered instanceof SetMultimap) {
      return emptySet();
    } else {
      return emptyList();
    }
  }

  @Override
  public void clear() {

# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

name: PR Automation
on:
  pull_request_target:
    types:
      - closed

jobs:
  pr-automation:
    name: PR Automation

import importlib
from types import ModuleType
from typing import Annotated, Any
from unittest.mock import Mock, patch

import pytest
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient


@pytest.fixture(
    name="module",
    params=[
        "tutorial008_py39",
        # Fails with `NameError: name 'DepA' is not defined`
        pytest.param("tutorial008_an_py39", marks=pytest.mark.xfail),
    ],
)

    assertThrows(NullPointerException.class, () -> multimap().putAll(null, singletonList(v3())));
  }

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyCollectionOnAbsentKey() {
    assertFalse(multimap().putAll(k3(), Collections.emptyList()));
    expectUnchanged();
  }

pkg go/constant, func ToInt(Value) Value
pkg go/constant, type Value interface, ExactString() string
pkg go/types, method (*Package) SetName(string)
pkg go/types, type ImportMode int
pkg go/types, type ImporterFrom interface { Import, ImportFrom }
pkg go/types, type ImporterFrom interface, Import(string) (*Package, error)
pkg go/types, type ImporterFrom interface, ImportFrom(string, string, ImportMode) (*Package, error)