print(f"Hey {name}!")
```

O parâmetro `name` é definido como `Optional[str]`, mas não é opcional; não é possível chamar a função sem o parâmetro:

```Python
say_hi()  # Ah, não, isso gera um erro! 😱
```

O parâmetro `name` continua obrigatório (não é opcional) porque não tem valor padrão. Ainda assim, `name` aceita `None` como valor:

```Python
say_hi(name=None)  # Isso funciona, None é válido 🎉
```

     */
    @Nullable
    XmlNode child(String name);

    /**
     * Returns the input location information for this node, if available.
     * This can be useful for error reporting and debugging.
     *
     * @return the input location object, or {@code null} if not available
     */
    @Nullable
    Object inputLocation();

    // Deprecated methods that delegate to new ones

	}

	if !owner {
		t.Fatalf("Expected owner to be 'true', found %t", owner)
	}

	_, _, s3Err = checkKeyValid(req, "does-not-exist")
	if s3Err != ErrInvalidAccessKeyID {
		t.Fatalf("Expected error 'ErrInvalidAccessKeyID', found %v", s3Err)
	}

	ucreds, err := auth.CreateCredentials("myuser1", "mypassword1")
	if err != nil {
		t.Fatalf("unable create credential, %s", err)
	}

                System.arraycopy(data, offset + 8, addr, 0, 16);
                return InetAddress.getByAddress(addr);
            }
        } catch (Exception e) {
            // Ignore parsing errors
        }
        return null;
    }

    private boolean checkRSSCapability() {
        // Platform-specific RSS detection - simplified implementation
        try {

        this.level = level
      }

    @JvmName("-deprecated_level")
    @Deprecated(
      message = "moved to var",
      replaceWith = ReplaceWith(expression = "level"),
      level = DeprecationLevel.ERROR,
    )
    fun getLevel(): Level = level

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
      val level = this.level

      val request = chain.request()

    /** Share level security */
    int SECURITY_SHARE = 0x00;
    /** User level security */
    int SECURITY_USER = 0x01;

    /** Command offset in SMB header */
    int CMD_OFFSET = 4;
    /** Error code offset in SMB header */
    int ERROR_CODE_OFFSET = 5;
    /** Flags offset in SMB header */
    int FLAGS_OFFSET = 9;
    /** Signature offset in SMB header */
    int SIGNATURE_OFFSET = 14;

            return false;
        }

        @Override
        public boolean isError() {
            return errorCode != 0;
        }

        @Override
        public void error() {
            this.errorCode = -1;
        }

        @Override
        public Long getExpiration() {
            return expiration;
        }

        @Override

		r = r.WithContext(newContext(r, w, handlerName))

		defer logger.AuditLog(r.Context(), w, r, mustGetClaimsFromToken(r))

		// Check if object layer is available, if not return error early.
		if !handlerFlags.Has(noObjLayerFlag) {
			objectAPI := newObjectLayerFn()
			if objectAPI == nil || globalNotificationSys == nil {

        final AtomicBoolean secondCalled = new AtomicBoolean(false);
        coordinatorHelper.addEventHandler("test_event", event -> {
            throw new RuntimeException("test error");
        });
        coordinatorHelper.addEventHandler("test_event", event -> secondCalled.set(true));

        final EventInfo event = new EventInfo();
        event.name = "test_event";

            }
          });
      try {
        future.get();
      } catch (Throwable t) {
        // Ignore, we just wanted to block.
      }
      String error = errorMessage.get();
      assertWithMessage(error).that(error).isNull();
    }
    executor.shutdown();
  }

  /**
   * He did the bash, he did the future bash The future bash, it was a concurrency smash He did the