fix(cddl2py): emit valid Python for .regexp operator

The template-annotated pattern logic produced invalid expressions like
`Annotated[str, "custom:" + str]`, which fails at runtime because you
cannot concatenate a string literal with the str type object. Complex
patterns (e.g. `[^@]+@[^@]+`) were also silently downgraded to bare
`str`, losing the constraint even in pydantic mode.

Store the regex pattern as a plain string annotation instead
(`Annotated[str, "custom:.+"]`), which is valid Python and preserves
the constraint as inspectable metadata.

Author: christian-bromann

packages/cddl2py/src/index.ts

@@ -517,37 +517,6 @@ function getExtraItemsType (props: Property[], ctx: Context): string | undefined
     return `Union[${uniqueTypes.join(', ')}]`
 }
 
-function stringifyPythonLiteral (value: string) {
-    return JSON.stringify(value)
-}
-
-function getTemplateAnnotatedPattern (regexpPattern: string): string | undefined {
-    const wildcard = '.+'
-    if (!regexpPattern.includes(wildcard) || /[\\()[\]{}|?*^$]/.test(regexpPattern.replaceAll(wildcard, ''))) {
-        return
-    }
-
-    const segments = regexpPattern.split(wildcard)
-    const parts: string[] = []
-
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i]
-        if (segment.length > 0) {
-            parts.push(stringifyPythonLiteral(segment))
-        }
-
-        if (i < segments.length - 1) {
-            parts.push('str')
-        }
-    }
-
-    if (parts.length === 0 || !parts.includes('str')) {
-        return
-    }
-
-    return `Annotated[str, ${parts.join(' + ')}]`
-}
-
 function resolveNativeTypeWithOperator (t: NativeTypeWithOperator, ctx: Context): string | undefined {
     if (typeof t.Type !== 'string') {
         return
@@ -566,21 +535,13 @@ function resolveNativeTypeWithOperator (t: NativeTypeWithOperator, ctx: Context)
         return mapped
     }
 
-    const templateAnnotatedPattern = getTemplateAnnotatedPattern(regexpPattern)
-    if (!templateAnnotatedPattern) {
-        if (mapped === 'Any') {
-            ctx.typingImports.add('Any')
-        }
-        return mapped
-    }
-
     ctx.typingImports.add('Annotated')
     if (ctx.pydantic) {
         ctx.pydanticImports.add('StringConstraints')
         return `Annotated[${mapped}, StringConstraints(pattern=${JSON.stringify(regexpPattern)})]`
     }
 
-    return templateAnnotatedPattern
+    return `Annotated[${mapped}, ${JSON.stringify(regexpPattern)}]`
 }
 
 // ---------------------------------------------------------------------------

packages/cddl2py/tests/transform_edge_cases.test.ts

@@ -205,18 +205,34 @@ describe('transform edge cases', () => {
                     Type: 'regexp',
                     Value: literal('custom:.+')
                 }
+            } as any),
+            variable('sandwiched-name', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('some_.+_name')
+                }
+            } as any),
+            variable('email-address', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('[^@]+@[^@]+')
+                }
             } as any)
         ], { pydantic: true })
 
         expect(typedDictOutput).toContain('from typing import Annotated')
-        expect(typedDictOutput).toContain('Channel = Annotated[str, "custom:" + str]')
-        expect(typedDictOutput).toContain('PrefixedName = Annotated[str, "foo_" + str]')
-        expect(typedDictOutput).toContain('SandwichedName = Annotated[str, "some_" + str + "_name"]')
-        expect(typedDictOutput).toContain('MultiSlotName = Annotated[str, "pre_" + str + "_mid_" + str + "_post"]')
-        expect(typedDictOutput).toContain('channel: Annotated[str, "custom:" + str]')
-        expect(typedDictOutput).toContain('EmailAddress = str')
+        expect(typedDictOutput).toContain('Channel = Annotated[str, "custom:.+"]')
+        expect(typedDictOutput).toContain('PrefixedName = Annotated[str, "foo_.+"]')
+        expect(typedDictOutput).toContain('SandwichedName = Annotated[str, "some_.+_name"]')
+        expect(typedDictOutput).toContain('MultiSlotName = Annotated[str, "pre_.+_mid_.+_post"]')
+        expect(typedDictOutput).toContain('channel: Annotated[str, "custom:.+"]')
+        expect(typedDictOutput).toContain('EmailAddress = Annotated[str, "[^@]+@[^@]+"]')
         expect(pydanticOutput).toContain('from pydantic import StringConstraints')
         expect(pydanticOutput).toContain('Channel = Annotated[str, StringConstraints(pattern="custom:.+")]')
+        expect(pydanticOutput).toContain('SandwichedName = Annotated[str, StringConstraints(pattern="some_.+_name")]')
+        expect(pydanticOutput).toContain('EmailAddress = Annotated[str, StringConstraints(pattern="[^@]+@[^@]+")]')
     })
 
     it('should collapse multiple union mixin groups into a single alias', () => {