if err != nil {
		return 0, err
	}
	var deviceCwd string
	if isStd {
		// Note that we use path.Join here instead of filepath.Join:
		// The device paths should be slash-separated even if the go_android_exec
		// wrapper itself is compiled for Windows.
		deviceCwd = path.Join(deviceGoroot, "src", importPath)
	} else {
		deviceCwd = path.Join(deviceGopath, "src", importPath)

Im Allgemeinen möchten Sie wahrscheinlich, dass das Serverprogramm (z. B. Uvicorn) beim Hochfahren des Servers automatisch gestartet wird und kein **menschliches Eingreifen** erforderlich ist, sodass immer ein Prozess mit Ihrer API ausgeführt wird (z. B. Uvicorn, welches Ihre FastAPI-Anwendung ausführt).

### Separates Programm { #separate-program }

     * {@code SmbFile} refers to a workgroup, server, share, or directory,
     * the name will include a trailing slash '/' so that composing new
     * {@code SmbFile}s will maintain the trailing slash requirement.
     *
     * @return  The last component of the URL associated with this SMB
     *          resource or <code>smb1://</code> if the resource is <code>smb1://</code>

             * path is just "\" and not "\example.com\root".
             */
            link = "\\";
        } else if (path.charAt(path.length() - 1) == '\\') {
            // strip trailing slash
            link = path.substring(0, path.length() - 1);
        } else {
            link = path;
        }

        if (log.isTraceEnabled()) {
            log.trace("Initial link is " + link);
        }

        if (matcher.find()) {
            return matcher.group(1);
        }
        return null;
    }

    /**
     * Gets a duplicate URL by adding or removing a trailing slash.
     *
     * @param requestData the request data to create a duplicate for
     * @return the request data with the duplicate URL
     */
    protected RequestData getDuplicateUrl(final RequestData requestData) {

		fi := v.h.FileInfo()
		h2, err := FileInfoHeader(fi, "")
		if err != nil {
			t.Error(err)
			continue
		}
		if strings.Contains(fi.Name(), "/") {
			t.Errorf("FileInfo of %q contains slash: %q", v.h.Name, fi.Name())
		}
		name := path.Base(v.h.Name)
		if fi.IsDir() {
			name += "/"
		}
		if got, want := h2.Name, name; got != want {
			t.Errorf("i=%d: Name: got %v, want %v", i, got, want)
		}

				// We may be in a situation where we have a directory and an object with the same name.
				// In that case we will drop the directory entry.
				// This should however not be confused with an object with a trailing slash.
				dirMatches := best.isDir() == other.isDir()
				suffixMatches := strings.HasSuffix(best.name, slashSeparator) == strings.HasSuffix(other.name, slashSeparator)

				// Simple case. Both are same type with same suffix.

	BaseDir string

	// Scan/return only content with prefix.
	Prefix string

	// FilterPrefix will return only results with this prefix when scanning.
	// Should never contain a slash.
	// Prefix should still be set.
	FilterPrefix string

	// Marker to resume listing.
	// The response will be the first entry >= this object name.
	Marker string

	// Limit the number of results.
	Limit int

			}
			if gnuLongLink != "" {
				hdr.Linkname = gnuLongLink
			}
			if hdr.Typeflag == TypeRegA {
				if strings.HasSuffix(hdr.Name, "/") {
					hdr.Typeflag = TypeDir // Legacy archives use trailing slash for directories
				} else {
					hdr.Typeflag = TypeReg
				}
			}

			// The extended headers may have updated the size.
			// Thus, setup the regFileReader again after merging PAX headers.

	if xdir != ydir {
		return strings.Compare(xdir, ydir)
	}
	return strings.Compare(xelem, yelem)
}

// Open opens the named file in the ZIP archive,
// using the semantics of fs.FS.Open:
// paths are always slash separated, with no
// leading / or ../ elements.
func (r *Reader) Open(name string) (fs.File, error) {
	r.initFileList()

	if !fs.ValidPath(name) {