myts 0.3.12

MyPy to TS generator

myts

In beta

Road to ready:

• Better test coverage, 80% baseline
• Support for generics, enums with auto, most MyPy typing.

Converts MyPy types to TS types. Uses MyPy's internal api to gather type info. Including your pydantic project if its MyPy friendly.

Call as a cli, optionally directory watchable. Or import and invoke directly from your Python code.

Installation

pip

pip install myts

uv

uv add myts 

poetry

poetry add myts

Usage

In your code

Myts looks for any classes that inherit from MytsType to start building its dependency graph. These by default will be included in the output TS.

Alternatively you can use the myts_export decorator on Enums and TypedDicts and classes that you would like to have exported without needing to be referenced by a MytsType class.

from enum import IntEnum
from myts import MytsType, myts_export

@myts_export
class Fruit(IntEnum): # Will be in the TS output
	apple = 0
	orange = 1
	banana = 2

class Vegetable(IntEnum): # Will not be, because it is not referenced ever and is not decorated with myts_export
	carrot = 0
	celery = 1
	lettuce = 2

class Drink(IntEnum): # Will be in the output, reference by a MytsType below
	water = 0
	milk = 1
	soda = 2

class BeveragePreference(MytsType): # Will export and will also export the Drink enum
	drink: Drink
	person: Person

CLI

To see all cli options run

myts -h

Optionally a config file can be used. By default myts will attempt to find a myts.toml in the specified root. Alternatively a config file can be supplied through the -c or --config argument to the cli.

You can also specify these options under a [tool.myts] section in your pyproject.toml found at the --root path.

Note: that arguments to the cli will override config settings found in the config.

The resolution of options is: (lowest → highest priority)

1. pyproject [tool.myts]
2. myts.toml
3. command line arguments

Meaning an option defined in [tool.myts] can and will be overwritten by the same option if provided to myts.toml or the command line.

myts.toml or [tool.myts] is a flat toml that can optionally supply any or none of the following:

root = "/some/path" # If specifying root in the config make sure it is an absolute path
output = "./out/" # When output is relative, it is relative to root
group = "module" # "module" or "single"
preserve_structure = true # When group is "module" this will create folders matching the py structure
dry_run = false
#output_file_name = "out.ts" # When using group = "single" this will be the name of the output file
#trim_root = "myapp.has.a.long.root.path" # Optionally provide a python formatted module path to trim from all output

Simplest example

To generate the .ts files.

cd <myprojectroot>
myts --output your/output/dir/

A more complex example

Uses trim-root to remove a common py module path from the output.

Uses watch to automatically update generated ts when the py changes.

cd <myprojectroot>
myts --output your/output/dir/ -w

Py

import pathlib
import myts
from myts.cli.main import extract_ts

config = myts.MytsConfiguration(
	root=pathlib.Path('someprojdir'), # defaults to os.cwd()
	output=pathlib.Path('someoutputdir'),
	group='module', # 'single' or 'module' - single will output a single .ts file, 'module' will output files matching the `py` files they come from
	preserve_structure=True, # No effect if group == 'single', otherwise determines output structure. If true folders will be created to match py paths
	dry_run=False, # If true, just prints the paths of output files that would be written
	output_file_name='types.ts', # Only used if group == 'single', determines the name of the single file generated
	trim_root="myapp.some.path" # When preserving structure, use this to trim a common root 
)

extract_ts(config)

Roadmap

• Export to multiple files, flat folder or matching py module structure
• Support generics
• Watch for py changes and auto generate ts
• Config options for
  • Variable and type naming options (camelCase, PascalCase, snake_case)
  • Interface vs type output
• Special support for pydantics built-ins (might build a plugin architecture to support)

Exporter configuration

Currently, myts only has 1 built-in exporter for ts. However it has been designed to easily support multiple exporters in the future, including the potential for custom exporters(actually achievable today, just without a "formal" plugin architecture).

The TS exporter can be configured by adding a [exporter.ts] section to your myts config:

[exporter.ts]
enum_output_format = "typed_const_map" # or "std_enum" to use TS enums. Default is typed_const_map for DX
typeddict_output_format = "interface" # or "type". Default interface to support inheritance
class_output_format = "interface" # or "type". Default interface to support inheritance
use_declare = true # default true, for any `type` declarations will precede with 'declare' if true
indent = "tabs" # default tabs, because they're superior, "spaces" is an option, currently the number of spaces is 4 and not yet configurable

Example of functionality

Python (Mypy)

from myts import MytsType, myts_export
from pydantic import BaseModel


class APIModel(BaseModel, MytsType):
	"""
		All pydantic models that extend from this will be picked up by Myts
	"""
	...


class MyPydanticModel(APIModel): # Myts will grab this
	name: str


class Fruits(Enum):
	APPLE = auto()
	BANANA = auto()
	GRAPES = auto()

class MyGenericClass[T: str | int]:
	my_var: T
	fruits: list[Fruits]

Output (Typescript)

export interface MyPedanticModel {
	name: string;
}

export const Fruits = {
	APPLE: 1,
	BANANA: 2,
	GRAPES: 3,
} as const;
export type Fruits = typeof Fruits[keyof typeof Fruits];

export interface MyGenericClass<T extends string | number> {
	myVar: T;
	fruits: Array<Fruits>;
}