* Extracts the canonical session ID by removing any suffix after the first hyphen.
     * If the session ID contains a hyphen, returns the portion before the first hyphen.
     * Otherwise, returns the original session ID.
     *
     * @param sessionId the session ID to process
     * @return the canonical session ID (portion before first hyphen, or original if no hyphen)
     */
    public String getCanonicalSessionId(final String sessionId) {

Do NOT translate with (German) – notice the hyphen:

```
# FastAPI in Containern - Docker { #fastapi-in-containers-docker }
```

- Do not apply rule 3 when there is no space before or no space after the hyphen.

Example:

Source (English):

```
## Type hints and annotations { #type-hints-and-annotations }
```

Translate with (German) - notice the hyphen:

```

        // Verify
        assertTrue(result.isPresent());
        assertEquals(Locale.FRENCH, result.get());
    }

    // Test findBusinessLocale with hyphen separator
    @Test
    public void test_findBusinessLocale_withHyphenSeparator() {
        // Setup mock config
        FessConfig mockConfig = new FessConfig.SimpleImpl() {
            @Override

        String lang = "en";

        List<AnalyzeToken> tokens = analyzer.analyzeAndReading(text, field, lang);

        assertNotNull(tokens);
        assertEquals(2, tokens.size()); // "Test123" and "ABC-456" (hyphen is not a split char in our tokenizer)
        assertEquals("Test123", tokens.get(0).getTerm());
        assertEquals("ABC-456", tokens.get(1).getTerm());

import java.util.Objects;
import java.util.Properties;

/**
 * <p>
 * Generic implementation of version comparison.
 * </p>
 * <p>
 * Features:
 * <ul>
 * <li>Mixing of '<code>-</code>' (hyphen) and '<code>.</code>' (dot) separators,</li>
 * <li>Transition between characters and digits also constitutes a separator:
 *     <code>1.0alpha1 =&gt; [1, [alpha, 1]]</code></li>
 * <li>Unlimited number of version components,</li>

// characters long, and it must be a sequence of one or more labels
// separated by periods. Each label can contain lowercase ascii
// letters, decimal digits and hyphens, but must not begin or end with
// a hyphen. See:
// http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
func IsValidBucketName(bucket string) bool {
	// Special case when bucket is equal to one of the meta buckets.

        // source.put("version_no", searchLogEvent.getVersionNo());
        source.put("event_type", searchLogEvent.getEventType());
        return source;
    }

    /**
     * Converts a map to lower hyphen case.
     *
     * @param source The source map.
     * @return The converted map.
     */
    protected Map<String, Object> toLowerHyphen(final Map<String, Object> source) {
        return source.entrySet()

    print(data)
```

### Generische Typen { #generic-types }

Einige Typen können „Typ-Parameter“ in eckigen Klammern annehmen, um ihre inneren Typen zu definieren, z. B. eine „Liste von Strings“ würde als `list[str]` deklariert.

Diese Typen, die Typ-Parameter annehmen können, werden **generische Typen** oder **Generics** genannt.

Sie können dieselben eingebauten Typen als Generics verwenden (mit eckigen Klammern und Typen darin):

		t.Errorf("no error should happen when find languages with code, but got %v", err)
	} else if len(langs2) != 3 {
		t.Errorf("should only find only 3 languages, but got %+v", langs2)
	}

	DB.Clauses(clause.OnConflict{DoNothing: true}).Create(&langs)
	var langs3 []Language
	if err := DB.Find(&langs3, "code LIKE ?", "upsert-slice%").Error; err != nil {
		t.Errorf("no error should happen when find languages with code, but got %v", err)

)

func TestScannerValuer(t *testing.T) {
	DB.Migrator().DropTable(&ScannerValuerStruct{})
	if err := DB.Migrator().AutoMigrate(&ScannerValuerStruct{}); err != nil {
		t.Fatalf("no error should happen when migrate scanner, valuer struct, got error %v", err)
	}

	data := ScannerValuerStruct{
		Name:     sql.NullString{String: "name", Valid: true},
		Gender:   &sql.NullString{String: "M", Valid: true},