// The iterator yields the same subslices that would be returned by [Split](s, sep),
// but without constructing a new slice containing the subslices.
// It returns a single-use iterator.
func SplitSeq(s, sep []byte) iter.Seq[[]byte] {
	return splitSeq(s, sep, 0)
}

// SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
// The iterator yields the same subslices that would be returned by [SplitAfter](s, sep),

You import it and create an "instance" the same way you would with the class `FastAPI`:

{* ../../docs_src/bigger_applications/app_an_py310/routers/users.py hl[1,3] title["app/routers/users.py"] *}

### *Path operations* with `APIRouter` { #path-operations-with-apirouter }

And then you use it to declare your *path operations*.

Use it the same way you would use the `FastAPI` class:

      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      long start = System.nanoTime();
      // here is where you would do something
      total += System.nanoTime() - start;
    }
    return total;
  }

* **`200 - 299`** are for "Successful" responses. These are the ones you would use the most.
    * `200` is the default status code, which means everything was "OK".
    * Another example would be `201`, "Created". It is commonly used after creating a new record in the database.

        assertEquals("Should still see 1 word from old index", 1, suggester.getAllWordsNum());

        // Switch search to new index
        suggester.switchIndex();
        suggester.refresh();

        // Now search sees new data
        assertEquals("Should see 1 word from new index", 1, suggester.getAllWordsNum());
    }

    @Test

                    final AnalyzeToken token = tokens.get(i);
                    final String word = token.getTerm();
                    if (StringUtil.isBlank(word)) {
                        continue;
                    }
                    final String[] words = { word };
                    final String[][] readings = new String[words.length][];
                    final List<String> l;

## JSON Lines { #json-lines }

In these cases, it's common to send "**JSON Lines**", which is a format where you send one JSON object per line.

A response would have a content type of `application/jsonl` (instead of `application/json`) and the body would be something like:

```json
{"name": "Plumbus", "description": "A multi-purpose household device."}
{"name": "Portal Gun", "description": "A portal opening device."}

  public void testRemove_nullKeyQueriesUnsupported() {
    try {
      assertFalse(getMap().remove(null, v3()));
    } catch (NullPointerException tolerated) {
      // since the operation would be a no-op, the exception is not required
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_VALUE_QUERIES)
  public void testRemove_nullValueQueriesUnsupported() {

        String content = "word\\n1\n" + // word + n + 1
                "word\\\n"; // word + (nothing after backslash)

        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
        stopwordsFile.reload(null, is);

        assertEquals(2, stopwordsFile.stopwordsItemList.size());
        // The content creates two lines: "word\n1" and "word\"

Import `File` and `UploadFile` from `fastapi`:

{* ../../docs_src/request_files/tutorial001_an_py310.py hl[3] *}

## Define `File` Parameters { #define-file-parameters }

Create file parameters the same way you would for `Body` or `Form`:

{* ../../docs_src/request_files/tutorial001_an_py310.py hl[9] *}

/// info

`File` is a class that inherits directly from `Form`.