typtyp 0.1.0__tar.gz

typtyp-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,70 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "v*"
+  pull_request:
+
+jobs:
+  Test:
+    runs-on: "${{ matrix.os }}"
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+        python-version:
+          - "3.11"
+          - "3.12"
+          - "3.13"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "${{ matrix.python-version }}"
+      - run: cd tests && npm i
+      - run: uv sync --all-extras
+      - run: uv run pytest -vvv --cov .
+
+  Lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: akx/pre-commit-uv-action@v0.1.0
+        env:
+          RUFF_OUTPUT_FORMAT: "github"
+
+  Build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+  Publish:
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
+    needs:
+      - Build
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+      url: https://pypi.org/p/typtyp/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          print-hash: true

typtyp-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+*.egg-info
+*.py[oc]
+.coverage
+.venv
+__pycache__/
+build/
+dist/
+uv.lock
+wheels/
+node_modules/
+pnpm-lock.yaml

typtyp-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.2
+    hooks:
+      - id: ruff
+        args:
+          - --fix
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+        exclude: .*ambr
+
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.1.0
+    hooks:
+      - id: prettier

typtyp-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2025 Aarni Koskela <akx@iki.fi>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

typtyp-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: typtyp
+Version: 0.1.0
+Summary: Convert Python types to TypeScript
+Author-email: Aarni Koskela <akx@iki.fi>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.0; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# typtyp
+
+Convert Python types and type annotations to TypeScript type definitions.
+
+## Features
+
+- Convert dataclasses, TypedDict, enums, and Pydantic models to TypeScript
+- Support for Python's standard typing primitives
+- Rich type support (dates, UUIDs, complex collections, etc.)
+- Simple API for declaring types for conversion
+
+## Installation
+
+```bash
+pip install typtyp
+```
+
+## Usage
+
+```python
+from dataclasses import dataclass
+from typing import List, Optional
+import typtyp
+
+@dataclass
+class User:
+    name: str
+    email: str
+    age: Optional[int] = None
+
+@dataclass
+class Team:
+    name: str
+    members: List[User]
+
+# Create a world to collect types
+world = typtyp.World()
+
+# Add types to the world
+world.add(User)
+world.add(Team)
+
+# Generate TypeScript
+typescript_code = world.get_typescript()
+print(typescript_code)
+```
+
+Output (approximately – you would want to run typtyp's output through a formatter of your liking):
+
+```typescript
+export interface User {
+  name: string;
+  email: string;
+  age: number | null;
+}
+
+export interface Team {
+  name: string;
+  members: User[];
+}
+```

typtyp-0.1.0/README.md

@@ -0,0 +1,61 @@
+# typtyp
+
+Convert Python types and type annotations to TypeScript type definitions.
+
+## Features
+
+- Convert dataclasses, TypedDict, enums, and Pydantic models to TypeScript
+- Support for Python's standard typing primitives
+- Rich type support (dates, UUIDs, complex collections, etc.)
+- Simple API for declaring types for conversion
+
+## Installation
+
+```bash
+pip install typtyp
+```
+
+## Usage
+
+```python
+from dataclasses import dataclass
+from typing import List, Optional
+import typtyp
+
+@dataclass
+class User:
+    name: str
+    email: str
+    age: Optional[int] = None
+
+@dataclass
+class Team:
+    name: str
+    members: List[User]
+
+# Create a world to collect types
+world = typtyp.World()
+
+# Add types to the world
+world.add(User)
+world.add(Team)
+
+# Generate TypeScript
+typescript_code = world.get_typescript()
+print(typescript_code)
+```
+
+Output (approximately – you would want to run typtyp's output through a formatter of your liking):
+
+```typescript
+export interface User {
+  name: string;
+  email: string;
+  age: number | null;
+}
+
+export interface Team {
+  name: string;
+  members: User[];
+}
+```

typtyp-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "typtyp"
+version = "0.1.0"
+license = "MIT"
+description = "Convert Python types to TypeScript"
+readme = "README.md"
+authors = [
+    { name = "Aarni Koskela", email = "akx@iki.fi" }
+]
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+#django = ["django"]
+pydantic = ["pydantic>=2.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.15.0",
+    "pyright>=1.1.397",
+    "pytest>=8.3.5",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.11.2",
+    "syrupy>=4.9.1",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+extend-select = [
+    "COM812",
+    "I",
+    "T201",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = [
+    "D",
+    "S101",
+    "UP",
+]
+
+[tool.coverage.report]
+exclude_also = [
+    'if 0:',
+    'if TYPE_CHECKING:',
+    'if __name__ == .__main__.:',
+    'raise AssertionError',
+]

typtyp-0.1.0/src/typtyp/__init__.py

@@ -0,0 +1,5 @@
+from typtyp.world import World
+
+__all__ = [
+    "World",
+]

typtyp-0.1.0/src/typtyp/excs.py

@@ -0,0 +1,2 @@
+class UnreferrableTypeError(ValueError):
+    pass

typtyp-0.1.0/src/typtyp/type_info.py

@@ -0,0 +1,11 @@
+import dataclasses
+
+
+@dataclasses.dataclass(frozen=True)
+class TypeInfo:
+    name: str
+    type: type
+    doc: str | None = None
+
+    # Consider `null`s in e.g. dataclasses as `undefined` in TypeScript
+    null_is_undefined: bool = False

typtyp-0.1.0/src/typtyp/typescript.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import collections
+import collections.abc
+import dataclasses
+import datetime
+import decimal
+import enum
+import inspect
+import ipaddress
+import json
+import pathlib
+import re
+import textwrap
+import types
+import typing
+import uuid
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, ForwardRef, NamedTuple, TextIO, TypeVar
+
+from typtyp.excs import UnreferrableTypeError
+from typtyp.type_info import TypeInfo
+
+if TYPE_CHECKING:
+    from typtyp.world import World
+
+
+RECORD_KEY_TS_TYPE = "string | number | symbol"
+
+
+def is_pydantic_model(t) -> bool:
+    try:
+        from pydantic import BaseModel
+
+        return issubclass(t, BaseModel)
+    except ImportError:  # pragma: no cover
+        return False
+
+
+class TypeAndKind(NamedTuple):
+    type: type
+    kind: str | None
+
+
+@dataclasses.dataclass(frozen=True)
+class TypeScriptContext:
+    fp: TextIO
+    world: World
+    null_is_undefined: bool = False
+    required_utility_types: dict[str, type] = dataclasses.field(default_factory=dict)
+
+    def sub(self, **replacements):
+        return dataclasses.replace(self, **replacements)
+
+    def write(self, s: str) -> None:
+        self.fp.write(s)
+
+
+def map_plain_type_ref(field_type: type, ts_context: TypeScriptContext) -> str:  # noqa: C901, PLR0911, PLR0912
+    try:
+        # This will handle enums as well – they need to have been registered
+        return ts_context.world.get_name_for_type(field_type)
+    except KeyError:
+        pass
+
+    # Special types
+
+    if isinstance(field_type, ForwardRef):
+        return f"unknown /* {field_type.__forward_arg__} */"
+    if type(field_type) is TypeVar:
+        return f"unknown /* {field_type} */"
+    if type(field_type) is type(Ellipsis):
+        return "unknown /* ... */"
+    if field_type is Any:
+        return "unknown /* any */"
+
+    if issubclass(field_type, (bytes, bytearray, memoryview)):
+        return f"unknown /* {field_type.__name__} */"
+
+    if issubclass(field_type, bool):
+        return "boolean"
+
+    if issubclass(field_type, complex):
+        return "[number, number] /* complex */"
+
+    if issubclass(field_type, (pathlib.Path, ipaddress._IPAddressBase, re.Pattern)):
+        return f"string /* {field_type.__name__} */"
+
+    if issubclass(field_type, (int, float, decimal.Decimal, datetime.timedelta)) and not issubclass(
+        field_type,
+        enum.Enum,
+    ):
+        return "number"
+
+    if issubclass(field_type, uuid.UUID):
+        ts_context.required_utility_types["UUID"] = str
+        return "UUID"
+
+    if issubclass(field_type, str) and not issubclass(field_type, enum.Enum):
+        return "string"
+
+    if issubclass(field_type, type(None)):
+        if ts_context.null_is_undefined:
+            return "undefined"
+        return "null"
+
+    if field_type is datetime.date:
+        ts_context.required_utility_types["ISO8601Date"] = str
+        return "ISO8601Date"
+
+    if field_type is datetime.time:
+        ts_context.required_utility_types["ISO8601Time"] = str
+        return "ISO8601Time"
+
+    if field_type is datetime.datetime:
+        ts_context.required_utility_types["ISO8601"] = str
+        return "ISO8601"
+
+    if issubclass(field_type, collections.Counter):
+        return f"Record<{RECORD_KEY_TS_TYPE}, number> /* Counter */"
+
+    if issubclass(field_type, dict):
+        comment = f" /* {field_type.__name__} */" if field_type is not dict else ""
+        return f"Record<{RECORD_KEY_TS_TYPE}, unknown>{comment}"
+
+    raise UnreferrableTypeError(f"Unable to refer to the type {field_type!r}; if it's a struct, add it to the world")
+
+
+def to_ts_function_declaration(field_type: type, ts_context: TypeScriptContext) -> str:
+    tps = typing.get_args(field_type)
+    if len(tps) == 2:
+        args_list, retval = tps
+        arglist = ", ".join(f"_{i}: {to_ts_type(arg, ts_context)}" for i, arg in enumerate(args_list))
+        return f"({arglist}) => {to_ts_type(retval, ts_context)}"
+    if len(tps) == 0:
+        return "Function"
+    raise AssertionError(f"Expected Callable with 0 or 2 types, got {tps}")
+
+
+def to_ts_type(field_type: type, ts_context: TypeScriptContext) -> str:  # noqa: C901, PLR0911, PLR0912
+    if isinstance(field_type, typing.NewType):
+        tp = to_ts_type(field_type.__supertype__, ts_context)  # pyright: ignore
+        return f"{tp} /* {field_type.__name__} */"
+
+    origin = typing.get_origin(field_type)
+
+    if origin is collections.abc.Callable:
+        return to_ts_function_declaration(field_type, ts_context)
+
+    if origin in (typing.Union, types.UnionType):
+        return " | ".join(to_ts_type(sub, ts_context) for sub in typing.get_args(field_type))
+
+    if origin is tuple:
+        tps = typing.get_args(field_type)
+        if tps and tps[-1] is Ellipsis:
+            if len(tps) != 2:
+                raise AssertionError(f"Expected tuple with one type and Ellipsis, got {tps}")
+            return f"[...{to_ts_type(tps[0], ts_context)}[]]"
+
+        return f"[{', '.join(to_ts_type(tp, ts_context) for tp in tps)}]"
+
+    if origin is typing.Literal:
+        return " | ".join(json.dumps(arg) for arg in typing.get_args(field_type))
+
+    # TODO: Smells like this could be done better with the ABCs...
+    if origin in (
+        list,
+        collections.deque,
+        set,
+        frozenset,
+        collections.abc.Iterable,
+        collections.abc.Iterator,
+        collections.abc.Sequence,
+    ):
+        comment = f" /* {origin.__name__} */" if origin is not list else ""
+        tps = typing.get_args(field_type)
+        if len(tps) != 1:
+            raise AssertionError(f"Expected list with one type, got {tps}")
+        inner = to_ts_type(tps[0], ts_context)
+        if inner.rstrip("[]").isalnum():
+            return f"({inner})[]{comment}"
+        return f"Array<{inner}>{comment}"
+
+    if origin is collections.Counter:
+        tps = typing.get_args(field_type)
+        if len(tps) != 1:
+            raise AssertionError(f"Expected Counter with one type, got {tps}")
+        return f"Record<{to_ts_type(tps[0], ts_context)}, number>"
+
+    if origin in (
+        dict,
+        collections.defaultdict,
+        collections.abc.Mapping,
+        collections.abc.MutableMapping,
+        collections.OrderedDict,
+    ):
+        comment = f" /* {origin.__name__} */" if origin is not dict else ""
+        tps = typing.get_args(field_type)
+        if len(tps) != 2:
+            raise AssertionError(f"Expected dict with two types, got {tps}")
+        return f"Record<{to_ts_type(tps[0], ts_context)}, {to_ts_type(tps[1], ts_context)}>{comment}"
+
+    if origin is not None:
+        raise NotImplementedError(f"Unknown origin {origin!r} for {field_type!r}")  # pragma: no cover
+
+    if hasattr(field_type, "_fields") and issubclass(field_type, tuple):
+        # NamedTuple defined inline? I guess, why not...
+        fields: list[str] = field_type._fields  # pyright: ignore
+        contents = (f"unknown /* {name} */" for name in fields)
+        return f"[{', '.join(contents)}] /* {field_type.__name__} */"
+
+    return map_plain_type_ref(field_type, ts_context)
+
+
+def get_struct_types(tp) -> list[tuple[str, Any]] | None:
+    if dataclasses.is_dataclass(tp):
+        return [(f.name, f.type) for f in dataclasses.fields(tp)]
+
+    if typing.is_typeddict(tp):
+        # TODO: support __total__
+        # TODO: support __required_keys__
+        # TODO: support __optional_keys__
+        return list(inspect.get_annotations(tp).items())
+
+    try:
+        if is_pydantic_model(tp):
+            return [(name, f.annotation) for (name, f) in sorted(tp.model_fields.items(), key=lambda item: item[0])]
+    except TypeError:  # pragma: no cover
+        pass
+
+    return None
+
+
+def write_structlike(ctx: TypeScriptContext, type_info: TypeInfo, name_and_type: Iterable[tuple[str, type]]) -> None:
+    ctx = ctx.sub(null_is_undefined=type_info.null_is_undefined)
+    ctx.write(f"interface {type_info.name} {{\n")
+    for name, typ in name_and_type:
+        ts_type = to_ts_type(typ, ts_context=ctx).strip()
+        field_suffix = ""
+        if "| undefined" in ts_type:
+            ts_type = ts_type.replace("| undefined", "")
+            field_suffix = "?"
+        ctx.write(f"{name}{field_suffix}: {ts_type}\n")
+    ctx.write("}\n")
+
+
+def write_enum(ctx: TypeScriptContext, type_info: TypeInfo) -> None:
+    ctx.write(f"const enum {type_info.name} {{\n")
+    for name, value in type_info.type.__members__.items():  # type: ignore
+        ctx.write(f"{name} = {json.dumps(value.value)},\n")
+    ctx.write("}\n")
+
+
+def write_type(ctx: TypeScriptContext, type_info: TypeInfo) -> None:
+    if type_info.doc:
+        ctx.write("/**\n")
+        for line in textwrap.dedent(type_info.doc).strip().splitlines():
+            ctx.write(f" * {line}\n")
+        ctx.write(" */\n")
+
+    if isinstance(type_info.type, type) and issubclass(type_info.type, enum.Enum):
+        return write_enum(ctx, type_info)
+
+    if (nt := get_struct_types(type_info.type)) is not None:
+        write_structlike(ctx, type_info, nt)
+    else:
+        ctx.write(f"type {type_info.name} = {to_ts_type(type_info.type, ctx)}\n")
+
+
+def write_ts(fp: typing.TextIO, world: World) -> None:
+    ctx = TypeScriptContext(fp=fp, world=world)
+    for type_info in ctx.world:
+        write_type(ctx, type_info)
+    for name, typ in sorted(ctx.required_utility_types.items()):
+        write_type(ctx, TypeInfo(name=name, type=typ))

typtyp-0.1.0/src/typtyp/world.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import io
+from typing import Iterable
+
+from typtyp.type_info import TypeInfo
+
+
+class _Sentinel:
+    pass
+
+
+NOT_SET = _Sentinel()
+
+
+class World:
+    def __init__(self) -> None:
+        self._types_by_name: dict[str, TypeInfo] = {}
+        self._types_by_type: dict[type, TypeInfo] = {}
+
+    def add(
+        self,
+        /,
+        typ: type,
+        *,
+        name: str | None = None,
+        doc: str | None | _Sentinel = NOT_SET,
+        null_is_undefined: bool = False,
+    ) -> TypeInfo:
+        if name is None:
+            name = typ.__name__
+        if isinstance(doc, _Sentinel):
+            # You're not a real doc...
+            real_doc = getattr(typ, "__doc__", None)
+        else:
+            real_doc = doc
+        assert name  # noqa: S101
+        if name in self._types_by_name:
+            raise KeyError(f"Type {name} already exists")
+        info = TypeInfo(name=name, type=typ, doc=real_doc, null_is_undefined=null_is_undefined)
+        self._types_by_name[name] = info
+        self._types_by_type[typ] = info
+        return info
+
+    def add_many(
+        self,
+        types: tuple[type, ...] | list[type] | set[type] | dict[str, type],
+        *,
+        doc: str | None | _Sentinel = NOT_SET,
+        null_is_undefined: bool = False,
+    ) -> dict[type, TypeInfo]:
+        types_it: Iterable[tuple[str | None, type]]
+        if isinstance(types, dict):
+            types_it = types.items()
+        else:
+            types_it = ((None, typ) for typ in types)
+        ret = {}
+        for name, typ in types_it:
+            ret[typ] = self.add(typ, name=name, doc=doc, null_is_undefined=null_is_undefined)
+        return ret
+
+    def get_name_for_type(self, t: type) -> str:
+        return self._types_by_type[t].name
+
+    def __iter__(self):
+        return iter(self._types_by_name.values())
+
+    def get_typescript(self) -> str:
+        from typtyp.typescript import write_ts
+
+        sio = io.StringIO()
+        write_ts(sio, self)
+        return sio.getvalue()

typtyp-0.1.0/tests/__snapshots__/test_dataclass.ambr

@@ -0,0 +1,20 @@
+# serializer version: 1
+# name: test_dataclass
+  '''
+  interface Person {
+  head: Head
+  name: string
+  }
+  interface Head {
+  size: number
+  hair_color: HairColor | null
+  }
+  const enum HairColor {
+  RED = "red",
+  BLACK = "black",
+  PURPLE = "purple",
+  BLUE = "blue",
+  }
+  
+  '''
+# ---

typtyp-0.1.0/tests/__snapshots__/test_kitchen_sink.ambr

@@ -0,0 +1,112 @@
+# serializer version: 1
+# name: test_kitchen_sink
+  '''
+  interface KitchenSink {
+  string_field: string
+  int_field: number
+  float_field: number
+  bool_field: boolean
+  none_field: null
+  complex_field: [number, number] /* complex */
+  decimal_field: number
+  list_field: Array<unknown /* any */>
+  int_list: (number)[]
+  nested_list: Array<(string)[]>
+  tuple_field: [number, string, boolean]
+  homogeneous_tuple: [...number[]]
+  empty_tuple: []
+  set_field: (string)[] /* set */
+  frozen_set: (number)[] /* frozenset */
+  dict_field: Record<string, unknown /* any */>
+  int_to_str_dict: Record<number, string>
+  nested_dict: Record<string, Record<string, (number)[]>>
+  default_dict: Record<string, number> /* defaultdict */
+  ordered_dict: Record<string, unknown /* any */> /* OrderedDict */
+  counter_dict: Record<string, number>
+  optional_field: string | null
+  union_field: number | string | boolean
+  optional_complex: Record<string, Array<[number, string]>> | null
+  datetime_field: ISO8601
+  date_field: ISO8601Date
+  time_field: ISO8601Time
+  timedelta_field: number
+  some_callable: Function
+  simple_callback: (_0: number) => boolean
+  complex_callback: (_0: string, _1: number, _2: Record<string, unknown /* any */>) => Array<[number, string]> | null
+  iterator_field: (number)[] /* Iterator */
+  iterable_field: (string)[] /* Iterable */
+  sequence_field: (number)[] /* Sequence */
+  mapping_field: Record<string, unknown /* any */> /* Mapping */
+  mutable_mapping: Record<string, number> /* MutableMapping */
+  deque_field: (string)[] /* deque */
+  literal_field: "red" | "green" | "blue"
+  literal_int: 1 | 2 | 3 | 5 | 8
+  regex_pattern: string /* Pattern */
+  user_id: string /* CustomID */
+  generic_container: Array<unknown /* ~T */>
+  file_path: string /* Path */
+  binary_data: unknown /* bytes */
+  bytearray_data: unknown /* bytearray */
+  memoryview_data: unknown /* memoryview */
+  ipv4_address: string /* IPv4Address */
+  ipv6_address: string /* IPv6Address */
+  uuid_field: UUID
+  status: Status
+  permissions: UnixPermissions
+  favorite_number: FavoriteNumberEnum
+  address: Address
+  point: [unknown /* x */, unknown /* y */, unknown /* z */] /* Point */
+  config: NestedConfig
+  named_tuple1: [unknown /* name */, unknown /* age */, unknown /* email */] /* Person */
+  named_tuple2: [unknown /* name */, unknown /* age */, unknown /* email */] /* Person2 */
+  any_field: unknown /* any */
+  ellipsis_field: unknown /* ... */
+  py_counter: Record<string | number | symbol, number> /* Counter */
+  py_defaultdict: Record<string | number | symbol, unknown> /* defaultdict */
+  py_ordered_dict: Record<string | number | symbol, unknown> /* OrderedDict */
+  recursive_field: unknown /* KitchenSink */
+  }
+  /**
+   * Address(street: str, city: str, postal_code: str, country: str)
+   */
+  interface Address {
+  street: string
+  city: string
+  postal_code: string
+  country: string
+  }
+  const enum Status {
+  PENDING = "pending",
+  ACTIVE = "active",
+  INACTIVE = "inactive",
+  }
+  const enum UnixPermissions {
+  READ = 1,
+  WRITE = 2,
+  EXECUTE = 4,
+  }
+  const enum FavoriteNumberEnum {
+  ONE = 1,
+  TWO = 2,
+  THREE = 3,
+  }
+  /**
+   * Point(x, y, z)
+   */
+  type Point = [unknown /* x */, unknown /* y */, unknown /* z */] /* Point */
+  interface NestedConfig {
+  timeout: number
+  retry_count: number
+  debug_mode: boolean
+  }
+  /**
+   * Person2(name, age, email)
+   */
+  type Person2 = [unknown /* name */, unknown /* age */, unknown /* email */] /* Person2 */
+  type ISO8601 = string
+  type ISO8601Date = string
+  type ISO8601Time = string
+  type UUID = string
+  
+  '''
+# ---

typtyp-0.1.0/tests/__snapshots__/test_pydantic.ambr

@@ -0,0 +1,20 @@
+# serializer version: 1
+# name: test_pydantic
+  '''
+  interface Person {
+  head: Head
+  name: string
+  }
+  const enum HairColor {
+  RED = "red",
+  BLACK = "black",
+  PURPLE = "purple",
+  BLUE = "blue",
+  }
+  interface Head {
+  hair_color: HairColor | null
+  size: number
+  }
+  
+  '''
+# ---

typtyp-0.1.0/tests/__snapshots__/test_typeddict.ambr

@@ -0,0 +1,23 @@
+# serializer version: 1
+# name: test_typeddict
+  '''
+  interface Person {
+  head: Head
+  name: string
+  }
+  const enum HairColor {
+  RED = "red",
+  BLACK = "black",
+  PURPLE = "purple",
+  BLUE = "blue",
+  }
+  interface Head {
+  size: number
+  hair_color: HairColor | null
+  }
+  interface Feet {
+  shoe_color?: "red" | "blue" 
+  }
+  
+  '''
+# ---

typtyp-0.1.0/tests/common.py

@@ -0,0 +1,9 @@
+import enum
+from enum import StrEnum
+
+
+class HairColor(StrEnum):
+    RED = "red"
+    BLACK = "black"
+    PURPLE = "purple"
+    BLUE = enum.auto()

typtyp-0.1.0/tests/helpers.py

@@ -0,0 +1,23 @@
+import pathlib
+import subprocess
+import tempfile
+import warnings
+
+TSC_PATH = pathlib.Path(__file__).parent / "node_modules" / ".bin" / "tsc"
+
+
+class TypeScriptFailed(Exception):
+    pass
+
+
+def check_with_tsc(code):
+    if not TSC_PATH.exists():  # pragma: no cover
+        warnings.warn("tsc not found, skipping TypeScript compilation check")
+        return True
+    with tempfile.NamedTemporaryFile(suffix=".ts") as ts_file:
+        ts_file.write(code.encode("utf-8"))
+        ts_file.flush()
+        result = subprocess.run([TSC_PATH, "--noEmit", ts_file.name], capture_output=True, encoding="utf-8")
+        if result.returncode != 0:  # pragma: no cover
+            raise TypeScriptFailed(result.stdout + result.stderr)
+        return True

typtyp-0.1.0/tests/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "typescript": "^5.8.2"
+  }
+}

typtyp-0.1.0/tests/test_dataclass.py

@@ -0,0 +1,24 @@
+import dataclasses
+
+import typtyp
+from tests.common import HairColor
+
+
+@dataclasses.dataclass
+class Head:
+    size: int
+    hair_color: HairColor | None
+
+
+@dataclasses.dataclass
+class Person:
+    head: Head
+    name: str
+
+
+def test_dataclass(snapshot):
+    w = typtyp.World()
+    # doc=None to avoid the silly docstrings generated by dataclasses
+    w.add_many({"Person": Person, "Head": Head}, doc=None)
+    w.add(HairColor)
+    assert w.get_typescript() == snapshot

typtyp-0.1.0/tests/test_errors.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import List
+
+import pytest
+
+import typtyp
+from typtyp.excs import UnreferrableTypeError
+
+
+@dataclass
+class User:
+    name: str
+
+
+@dataclass
+class Team:
+    name: str
+    members: List[User]
+    admins: list[User]
+
+
+def test_unreferrable():
+    world = typtyp.World()
+    world.add(Team)
+    with pytest.raises(UnreferrableTypeError):
+        # We forgot to explicitly add `User`.
+        world.get_typescript()
+
+
+def test_duplicate():
+    world = typtyp.World()
+    world.add(str, name="Team")
+    with pytest.raises(KeyError):
+        world.add(Team)

typtyp-0.1.0/tests/test_kitchen_sink.py

@@ -0,0 +1,240 @@
+import re
+from collections import Counter as PyCounter
+from collections import OrderedDict as PyOrderedDict
+from collections import defaultdict, namedtuple
+from dataclasses import dataclass
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum, Flag, IntEnum, auto
+from ipaddress import IPv4Address, IPv6Address
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Counter,
+    DefaultDict,
+    Deque,
+    Dict,
+    FrozenSet,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Literal,
+    Mapping,
+    MutableMapping,
+    NamedTuple,
+    NewType,
+    Optional,
+    OrderedDict,
+    Protocol,
+    Sequence,
+    Set,
+    Tuple,
+    TypedDict,
+    TypeVar,
+    Union,
+)
+from uuid import UUID
+
+import typtyp
+from tests.helpers import check_with_tsc
+
+T = TypeVar("T")
+CustomID = NewType("CustomID", str)
+
+
+# Enum classes
+class Status(Enum):
+    PENDING = "pending"
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+
+class UnixPermissions(Flag):
+    READ = auto()
+    WRITE = auto()
+    EXECUTE = auto()
+
+
+class NumEnum(IntEnum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+
+
+# Protocol definition
+class Serializable(Protocol):
+    def to_json(self) -> str: ...
+
+
+# Dataclass for nested type
+@dataclass
+class Address:
+    street: str
+    city: str
+    postal_code: str
+    country: str
+
+
+# NamedTuple example
+class Point(NamedTuple):
+    x: float
+    y: float
+    z: float = 0.0
+
+
+# Complex TypedDict
+class NestedConfig(TypedDict):
+    timeout: int
+    retry_count: int
+    debug_mode: bool
+
+
+Person2 = namedtuple("Person2", ["name", "age", "email"])
+
+
+# The kitchen sink with ALL the types!
+class KitchenSink(Generic[T], TypedDict, total=False):
+    # Basic types
+    string_field: str
+    int_field: int
+    float_field: float
+    bool_field: bool
+    none_field: None
+
+    # Complex number
+    complex_field: complex
+
+    # Numeric specialized
+    decimal_field: Decimal
+
+    # Collections
+    list_field: List[Any]
+    int_list: List[int]
+    nested_list: List[List[str]]
+
+    # Tuples of various forms
+    tuple_field: Tuple[int, str, bool]
+    homogeneous_tuple: Tuple[int, ...]
+    empty_tuple: Tuple[()]
+
+    # Sets and variants
+    set_field: Set[str]
+    frozen_set: FrozenSet[int]
+
+    # Dictionaries and variants
+    dict_field: Dict[str, Any]
+    int_to_str_dict: Dict[int, str]
+    nested_dict: Dict[str, Dict[str, List[int]]]
+    default_dict: DefaultDict[str, int]
+    ordered_dict: OrderedDict[str, Any]
+    counter_dict: Counter[str]
+
+    # Optional and Union
+    optional_field: Optional[str]
+    union_field: Union[int, str, bool]
+    optional_complex: Optional[Dict[str, List[Tuple[int, str]]]]
+
+    # Time-related
+    datetime_field: datetime
+    date_field: date
+    time_field: time
+    timedelta_field: timedelta
+
+    # Callable signatures
+    some_callable: Callable
+    simple_callback: Callable[[int], bool]
+    complex_callback: Callable[[str, int, Dict[str, Any]], Optional[List[Tuple[int, str]]]]
+
+    # Iterables
+    iterator_field: Iterator[int]
+    iterable_field: Iterable[str]
+    sequence_field: Sequence[float]
+
+    # Mappings
+    mapping_field: Mapping[str, Any]
+    mutable_mapping: MutableMapping[str, int]
+
+    # Specialized collections
+    deque_field: Deque[str]
+
+    # Type references
+    # TODO: type_reference: Type[Address]
+
+    # Literals
+    literal_field: Literal["red", "green", "blue"]
+    literal_int: Literal[1, 2, 3, 5, 8]
+
+    # Final (constant)
+    # final_value: Final[str]
+
+    # ClassVar
+    # class_variable: ClassVar[Dict[str, Any]]
+
+    # Regular expressions
+    regex_pattern: re.Pattern
+
+    # Custom type with NewType
+    user_id: CustomID
+
+    # Generic with TypeVar
+    generic_container: List[T]
+
+    # Path and file-related
+    file_path: Path
+
+    # Binary data
+    binary_data: bytes
+    bytearray_data: bytearray
+    memoryview_data: memoryview
+
+    # Network-related
+    ipv4_address: IPv4Address
+    ipv6_address: IPv6Address
+
+    # UUID
+    uuid_field: UUID
+
+    # Protocol type
+    # TODO: serializable_obj: Serializable
+
+    # Enum types
+    status: Status
+    permissions: UnixPermissions
+    favorite_number: NumEnum
+
+    # Nested structures
+    address: Address
+    point: Point
+    config: NestedConfig
+
+    # Named tuple defined here
+    named_tuple1: namedtuple("Person", ["name", "age", "email"])  # type: ignore
+    named_tuple2: Person2
+
+    # Special types
+    any_field: Any
+    ellipsis_field: ...  # type: ignore
+
+    # Raw Python objects (non-typing)
+    py_counter: PyCounter
+    py_defaultdict: defaultdict
+    py_ordered_dict: PyOrderedDict
+
+    # Recursive type references
+    recursive_field: "KitchenSink"
+
+
+def test_kitchen_sink(snapshot):
+    w = typtyp.World()
+    w.add(KitchenSink)
+    w.add(Address)
+    w.add_many((Status, UnixPermissions))
+    w.add(NumEnum, name="FavoriteNumberEnum")
+    w.add(Point)
+    w.add(NestedConfig)
+    w.add(Person2)
+    code = w.get_typescript()
+    assert code == snapshot
+    assert check_with_tsc(code)

typtyp-0.1.0/tests/test_pydantic.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING
+
+import pytest
+
+import typtyp
+from tests.common import HairColor
+from tests.helpers import check_with_tsc
+
+if TYPE_CHECKING:
+    import pydantic
+else:
+    pydantic = pytest.importorskip("pydantic")
+
+
+class Head(pydantic.BaseModel):
+    size: int
+    hair_color: HairColor | None
+
+
+class Person(pydantic.BaseModel):
+    head: Head
+    name: str
+
+
+def test_pydantic(snapshot):
+    w = typtyp.World()
+    w.add_many((Person, HairColor, Head))
+    code = w.get_typescript()
+    assert code == snapshot
+    assert check_with_tsc(code)

typtyp-0.1.0/tests/test_typeddict.py

@@ -0,0 +1,28 @@
+from typing import Literal, Optional, TypedDict, Union
+
+import typtyp
+from tests.common import HairColor
+from tests.helpers import check_with_tsc
+
+
+class Head(TypedDict):
+    size: int
+    hair_color: HairColor | None
+
+
+class Feet(TypedDict):
+    shoe_color: Optional[Union[Literal["red"], Literal["blue"]]]
+
+
+class Person(TypedDict):
+    head: Head
+    name: str
+
+
+def test_typeddict(snapshot):
+    w = typtyp.World()
+    w.add_many((Person, HairColor, Head))
+    w.add(Feet, null_is_undefined=True)
+    code = w.get_typescript()
+    assert check_with_tsc(code)
+    assert code == snapshot