```

</div>

entonces la variable interna `__name__` en tu archivo, creada automáticamente por Python, tendrá como valor el string `"__main__"`.

Así que, la sección:

```Python
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

se ejecutará.

---

Esto no ocurrirá si importas ese módulo (archivo).

Entonces, si tienes otro archivo `importer.py` con:

```Python
from myapp import app

        String host = getTargetHost();
        if (host == null) {
            host = trans.getRemoteAddress().getHostAddress();
            try {
                host = trans.getRemoteAddress().getHostName();
            } catch (Exception e) {
                log.debug("Failed to resolve host name", e);
            }
        }

        if (log.isDebugEnabled()) {

			},
			Object: event.Object{
				Key:       keyName,
				VersionID: args.Object.VersionID,
				Sequencer: uniqueID,
			},
		},
		Source: event.Source{
			Host:      args.Host,
			UserAgent: args.UserAgent,
		},
	}

	isRemovedEvent := args.EventName == event.ObjectRemovedDelete ||
		args.EventName == event.ObjectRemovedDeleteMarkerCreated ||

                fessLogPath = "../../logs";
            }
            op.replace("fess.log.path", fessLogPath.replace("\\", "/"));
        }).asYouLikeIt(resource -> {
            final Host host = resource.getHost();
            if (host instanceof final StandardHost standardHost) {
                standardHost.setErrorReportValveClass(SuppressErrorReportValve.class.getName());
            }

		}
		if !enabled {
			continue
		}
		var brokers []xnet.Host
		kafkaBrokers := getCfgVal(EnvKafkaBrokers, k, kv.Get(KafkaBrokers))
		if len(kafkaBrokers) == 0 {
			return cfg, config.Errorf("kafka 'brokers' cannot be empty")
		}
		for s := range strings.SplitSeq(kafkaBrokers, config.ValueSeparator) {
			var host *xnet.Host
			host, err = xnet.ParseHost(s)
			if err != nil {
				break
			}

            sharedMemoryAddress = "javadebug"
            host = "localhost"
            port = 5005
            autoRestart = true
        }
        create<Remote>("Launcher debug (port 5006)") {
            mode = Remote.RemoteMode.LISTEN
            transport = Remote.RemoteTransport.SOCKET
            sharedMemoryAddress = "javadebug"
            host = "localhost"
            port = 5006
            autoRestart = true

		case "ID":
			err = dc.ReadExactBytes((z.ID)[:])
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "Host":
			z.Host, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Host")
				return
			}
		case "Time":
			z.Time, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "Time")
				return
			}

            when(mockInetAddress.getHostName()).thenReturn("inet-host");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("inet-host", uniAddress.getHostName());
        }

        @Test
        void shouldReturnNbtAddressHostnameWhenWrappedIsNbtAddress() {
            when(mockNbtAddress.getHostName()).thenReturn("nbt-host");
            UniAddress uniAddress = new UniAddress(mockNbtAddress);

* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>

///

### Ativar headers encaminhados pelo proxy { #enable-proxy-forwarded-headers }

    assertThat(calls.size).isEqualTo(1)
    val url = server.url("/").toUrl()
    val call = calls[0]
    assertThat(call).contains("host=" + url.host)
    assertThat(call).contains("port=" + url.port)
    assertThat(call).contains("site=" + url.host)
    assertThat(call).contains("url=$url")
    assertThat(call).contains("type=" + java.net.Authenticator.RequestorType.SERVER)