At the same point, you try to trigger the autocomplete with `Ctrl+Space` and you see:

<img src="/img/python-types/image02.png">

With that, you can scroll, seeing the options, until you find the one that "rings a bell":

<img src="/img/python-types/image03.png">

## More motivation

Check this function, it already has type hints:

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

        assertConfigCacheDiscarded()
    }

    @Issue("https://github.com/gradle/gradle/issues/19663")
    def "fails when disabling reaching out to key servers after previous successful build and no key rings file"() {
        given:
        createMetadataFile {
            keyServer(keyServerFixture.uri)
            verifySignatures()
            addTrustedKey("org:foo:1.0", validPublicKeyHexString)

			srvErr <- fmt.Errorf("server: timeout waiting for connection to close")
			return
		case <-srvSPDYConn.CloseChan():
		}

		// Count pings sent by the server.
		gotPings := atomic.LoadInt64(&pingsSent)
		if gotPings < 1 {
			t.Errorf("server: failed to send any pings (check logs)")
		}
	}()

	// Set up client connection.
	clConn, err := net.Dial("tcp4", listener.Addr().String())
	if err != nil {

// whereas MaxServerConnectionAge* options are applicable on the server side only
// (as implied by the options' name...)
type Options struct {
	// After a duration of this time if the server/client doesn't see any activity it pings the peer to see if the transport is still alive.
	Time time.Duration
	// After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that
	// the connection is closed.

@ServiceScope(Scope.Global.class)
public interface FileLockContentionHandler {
    void start(long lockId, Consumer<FileLockReleasedSignal> whenContended);

    void stop(long lockId);

    int reservePort();

    /**
     * Pings the lock owner with the give port to start the lock releasing
     * process in the owner. May not ping the owner if:
     * - The owner was already pinged about the given lock before and the lock release is in progress

  /** True if this web socket failed and the listener has been notified. */
  private var failed = false

  /** Total number of pings sent by this web socket. */
  private var sentPingCount = 0

  /** Total number of pings received by this web socket. */
  private var receivedPingCount = 0

  /** Total number of pongs received by this web socket. */
  private var receivedPongCount = 0

        propertyNames.contains("ccCompiler")
        propertyNames.contains("idore")
        propertyNames.contains("tings")
    }

    def "deviant bean properties are considered as such by Groovy"() {
        when:
        def bean = new DeviantBean()
        bean.tings = 'Some settings'

        then:
        bean.tingStarted == 'Getting started!'
        bean.idore == true
    }

		participle.CaseInsensitive("Keyword"),
	)
	cases := []struct {
		str string
		res []interface{}
	}{
		{"s.title", []interface{}{"Murder on the Orient Express", "The Robots of Dawn", "Pigs Have Wings"}},
		{"s.authorInfo.yearRange", []interface{}{[]interface{}{1890.0, 1976.0}, []interface{}{1920.0, 1992.0}, []interface{}{1881.0, 1975.0}}},
		{"s.authorInfo.name", []interface{}{"Agatha Christie", "Isaac Asimov", "P. G. Wodehouse"}},

     *
     * The default value of 0 disables client-initiated pings.
     */
    fun pingInterval(
      interval: Long,
      unit: TimeUnit,
    ) = apply {
      pingInterval = checkDuration("interval", interval, unit)
    }

    /**
     * Sets the interval between HTTP/2 and web socket pings initiated by this client. Use this to

    assertThat(server.receivedPongCount()).isEqualTo(0)
    closeWebSockets(webSocket, server)
  }

  /**
   * Configure the websocket to send pings every 500 ms. Artificially prevent the server from
   * responding to pings. The client should give up when attempting to send its 2nd ping, at about
   * 1000 ms.
   */
  @Test
  fun unacknowledgedPingFailsConnection() {
    assumeNotWindows()