@app.post("/file_list_before_form")
def file_list_before_form(
    files: Annotated[list[bytes], File()],
    city: Annotated[str, Form()],
):
    return {"file_contents": files, "city": city}


@app.post("/file_list_after_form")
def file_list_after_form(
    city: Annotated[str, Form()],
    files: Annotated[list[bytes], File()],
):
    return {"file_contents": files, "city": city}


client = TestClient(app)

                return ids.equals(other.ids)
                        && files.equals(other.files)
                        && timestamps.equals(other.timestamps)
                        && sizes.equals(other.sizes);
            } else {
                return false;
            }
        }

        @Override
        public String toString() {
            return files.toString();
        }
    }

import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.MODULES;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Files.POM_XML;

/**
 * Discovers and loads Maven POM files in a Maven project hierarchy.
 *
 * <p>This class recursively discovers all POM files in a Maven project hierarchy
 * and loads them as domtrip Documents. Individual strategies can create domtrip Editors

        FileOutputStream out = new FileOutputStream(file);
        try {
          out.write(initialBytes);
        } finally {
          out.close();
        }
        return Files.asByteSink(file, FileWriteMode.APPEND);
      }
      return Files.asByteSink(file);
    }

    @Override
    public byte[] getExpected(byte[] bytes) {
      if (initialBytes == null) {
        return checkNotNull(bytes);
      } else {

# Auto detect text files and perform LF normalization
* text=auto

# Known text files
*.java text
*.xml text
*.yml text
*.md text
*.sh text
*.css text
*.txt text

# Known binary files

            return ZipInputStream(Files.newInputStream(file))
        }
    }

    /**
     * Implementation code that can be unit-tested.
     *
     * <p>Visible for testing.</p>
     */
    class Implementation(private val excludes: List<String>, private val includes: List<String>) {
        fun collectPackages(files: Iterable<Path>): Trie {
            val builder = Trie.Builder()

            } finally {
                // Clean up - delete all files in the directory first
                try {
                    Files.walk(tempDir)
                            .sorted(java.util.Comparator.reverseOrder())
                            .forEach(path -> {
                                try {
                                    Files.deleteIfExists(path);
                                } catch (Exception e) {

		return dotFile
	}

	dir, elem, _ := split(name)
	files := r.fileList
	i, _ := slices.BinarySearchFunc(files, dir, func(a fileListEntry, dir string) (ret int) {
		idir, ielem, _ := split(a.name)
		if dir != idir {
			return strings.Compare(idir, dir)
		}
		return strings.Compare(ielem, elem)
	})
	if i < len(files) {
		fname := files[i].name

            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-red",
                  "mode": "fixed"
                }
              }
            ]
          },
          {
            "matcher": {
              "id": "byName",
              "options": "S3 Requests"
            },

from fastapi.responses import HTMLResponse

app = FastAPI()


@app.post("/files/")
async def create_files(
    files: list[bytes] = File(description="Multiple files as bytes"),
):
    return {"file_sizes": [len(file) for file in files]}


@app.post("/uploadfiles/")
async def create_upload_files(
    files: list[UploadFile] = File(description="Multiple files as UploadFile"),
):
    return {"filenames": [file.filename for file in files]}