You can define a <dfn title="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings.">regular expression</dfn> `pattern` that the parameter should match:

{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}

This specific regular expression pattern checks that the received parameter value:

* `^`: starts with the following characters, doesn't have characters before.

{
  "resources": [
    {"pattern": "web-platform-test-urltestdata.txt"}
  ]

    assertThat(ArbitraryInstances.get(GenericDeclaration.class)).isNotNull();
  }

  public void testGet_regex() {
    assertThat(ArbitraryInstances.get(Pattern.class).pattern())
        .isEqualTo(Pattern.compile("").pattern());
    assertEquals(0, ArbitraryInstances.get(MatchResult.class).groupCount());
  }

  public void testGet_usePublicConstant() {

        }

        assertEquals(threadCount * opsPerThread, successCount.get(), "All operations should succeed");
    }

    /**
     * Test that session release with double-check pattern prevents race conditions.
     */
    @Test
    public void testSessionReleaseDoubleCheckPattern() throws Exception {
        // Given

	rulesCase7.Add(NewPattern("", "*.jpg"), TargetID{"1", "webhook"})

	rulesCase8 := make(Rules)
	rulesCase8.Add(NewPattern("2010*", ""), TargetID{"1", "webhook"})

	testCases := []struct {
		rules          Rules
		pattern        string
		targetID       TargetID
		expectedResult int
	}{
		{rulesCase1, NewPattern("*", ""), TargetID{"1", "webhook"}, 1},
		{rulesCase2, NewPattern("*", ""), TargetID{"2", "amqp"}, 2},

{
	"id": "0001",
	"type": "donut",
	"name": "Cake",
	"ppu": 0.55,
	"batters":
		{
			"batter":
				[
					{ "id": "1001", "type": "Regular" },
					{ "id": "1002", "type": "Chocolate" },
					{ "id": "1003", "type": "Blueberry" },
					{ "id": "1004", "type": "Devil's Food" }
				]
		},
	"topping":
		[
			{ "id": "5001", "type": "None" },
			{ "id": "5002", "type": "Glazed" },
			{ "id": "5005", "type": "Sugar" },

    GeneratorType: list,
    IPv4Address: str,
    IPv4Interface: str,
    IPv4Network: str,
    IPv6Address: str,
    IPv6Interface: str,
    IPv6Network: str,
    NameEmail: str,
    Path: str,
    Pattern: lambda o: o.pattern,
    SecretBytes: str,
    SecretStr: str,
    set: list,
    UUID: str,
    Url: str,
    AnyUrl: str,
}


def generate_encoders_by_class_tuples(

public class CharMappingCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(CharMappingCreator.class);

    /**
     * Constructs a new CharMappingCreator with the mapping file pattern.
     */
    public CharMappingCreator() {
        super("mapping.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager after construction.
     */
    @PostConstruct

                                                            pattern="yyyy-MM-dd'T'HH:mm:ss"/></td>
                                                    <td><c:if test="${data.endTime!=null}">
                                                        <fmt:formatDate value="${fe:date(data.endTime)}"
                                                                        pattern="yyyy-MM-dd'T'HH:mm:ss"/>

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(
    q: str | None = Query(
        default=None, min_length=3, max_length=50, pattern="^fixedquery$"
    ),
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})