*/
  open fun callStart(call: Call) {
  }

  /**
   * Invoked prior to a proxy selection.
   *
   * This will be invoked for route selection regardless of whether the client
   * is configured with a single proxy, a proxy selector, or neither.
   *
   * @param url a URL with only the scheme, hostname, and port specified.
   */
  open fun proxySelectStart(
    call: Call,

  /**
   * Invoked when an event source has been accepted by the remote peer and may begin transmitting
   * events.
   */
  open fun onOpen(
    eventSource: EventSource,
    response: Response,
  ) {
  }

  /**
   * TODO description.
   */
  open fun onEvent(
    eventSource: EventSource,
    id: String?,
    type: String?,
    data: String,
  ) {
  }

  /**

@SuppressSignatureCheck
sealed class ConnectionEvent {
  abstract val timestampNs: Long
  open val connection: Connection?
    get() = null

  /** Returns if the event closes this event, or null if this is no open event. */
  open fun closes(event: ConnectionEvent): Boolean? = null

  val name: String
    get() = javaClass.simpleName

  data class ConnectStart(

    }
  }

  /**
   * Returns true if this stream is open. A stream is open until either:
   *
   *  * A `SYN_RESET` frame abnormally terminates the stream.
   *  * Both input and output streams have transmitted all data and headers.
   *
   * Note that the input stream may continue to yield data even after a stream reports itself as
   * not open. This is because input data is buffered.
   */
  val isOpen: Boolean

 *
 * ### Android Cleartext Permit Detection
 *
 * Supported on Android 6.0+ via `NetworkSecurityPolicy`.
 */
open class Platform {
  /** Prefix used on custom headers. */
  fun getPrefix() = "OkHttp"

  open fun newSSLContext(): SSLContext = SSLContext.getInstance("TLS")

  open fun platformTrustManager(): X509TrustManager {
    val factory =
      TrustManagerFactory.getInstance(

import java.net.ServerSocket
import javax.net.ServerSocketFactory

/**
 * A [ServerSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureServerSocket].
 */
open class DelegatingServerSocketFactory(private val delegate: ServerSocketFactory) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {

   * request bodies.
   */
  open fun peek(): MockResponse {
    return MockResponse(socketPolicy = KeepOpen)
  }

  /**
   * Release any resources held by this dispatcher. Any requests that are currently being dispatched
   * should return immediately. Responses returned after shutdown will not be transmitted: their
   * socket connections have already been closed.
   */
  open fun shutdown() {}

```Python hl_lines="1  13"
{!../../../docs_src/events/tutorial003.py!}
```

Ein **Kontextmanager** in Python ist etwas, das Sie in einer `with`-Anweisung verwenden können, zum Beispiel kann `open()` als Kontextmanager verwendet werden:

```Python
with open("file.txt") as file:
    file.read()
```

In neueren Versionen von Python gibt es auch einen **asynchronen Kontextmanager**. Sie würden ihn mit `async with` verwenden:

```Python

```Python hl_lines="1  13"
{!../../../docs_src/events/tutorial003.py!}
```

Um **gerenciador de contexto** em Python é algo que você pode usar em uma declaração `with`, por exemplo, `open()` pode ser usado como um gerenciador de contexto:

```Python
with open("file.txt") as file:
    file.read()
```

Nas versões mais recentes de Python, há também um **gerenciador de contexto assíncrono**. Você o usaria com `async with`:

```Python

            .asSequence()
            .filterIsInstance<ConstructorDescriptor>()
            .map { it.toKtConstructorSymbol(analysisContext) }
    }

}

internal open class KtFe10ScopeMember(
    override val scope: MemberScope,
    private val constructors: Collection<ConstructorDescriptor>,
    override val analysisContext: Fe10AnalysisContext
) : KtFe10ScopeResolution() {