typespy 0.1.0__tar.gz

typespy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RasmusNygren
+
+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.

typespy-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: typespy
+Version: 0.1.0
+Summary: Detect python calling types
+Author: Rasmus Nygren
+Maintainer: Rasmus Nygren
+Project-URL: Homepage, https://github.com/rasmusnygren/typespy
+Project-URL: Repository, https://github.com/rasmusnygren/typespy
+Keywords: type detection,type tracing,typing
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+Typespy
+=======
+Figure out which types your modules are being called with.
+
+## Installation
+```bash
+pip install typespy
+```
+
+## Usage
+```bash
+usage: typespy [-h] [--verbose] module_names [module_names ...] dir
+
+Analyze function call type information
+
+positional arguments:
+  module_names  Name of the modules to analyze
+  dir           Path to the root directory of repositories
+
+options:
+  -h, --help    show this help message and exit
+  --verbose     Print function calls with file locations
+```

typespy-0.1.0/README.md

@@ -0,0 +1,23 @@
+Typespy
+=======
+Figure out which types your modules are being called with.
+
+## Installation
+```bash
+pip install typespy
+```
+
+## Usage
+```bash
+usage: typespy [-h] [--verbose] module_names [module_names ...] dir
+
+Analyze function call type information
+
+positional arguments:
+  module_names  Name of the modules to analyze
+  dir           Path to the root directory of repositories
+
+options:
+  -h, --help    show this help message and exit
+  --verbose     Print function calls with file locations
+```

typespy-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools >= 77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "typespy"
+version = "0.1.0"
+description = "Detect python calling types"
+readme = "README.md"
+license-files = ["LICENSE"]
+keywords = ["type detection", "type tracing", "typing"]
+authors = [
+    {name = "Rasmus Nygren"}
+]
+maintainers = [
+    {name = "Rasmus Nygren"}
+]
+requires-python = ">=3.10"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/rasmusnygren/typespy"
+Repository = "https://github.com/rasmusnygren/typespy"
+
+[project.scripts]
+typespy = "typespy:main"

typespy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

typespy-0.1.0/tests/test_analyze.py

@@ -0,0 +1,280 @@
+import ast
+
+import pytest
+
+from typespy import ModuleCallVisitor
+from typespy import analyze_file
+from typespy import find_import_aliases
+from typespy import infer_type
+
+
+@pytest.fixture
+def tmp_file(tmp_path):
+    yield tmp_path / "a.py"
+
+
+@pytest.mark.parametrize(
+    "content, expected_type", [
+        ("'hello'", "str"),
+        ("42", "int"),
+        ("[1, 2, 3]", "list[int]"),
+        ("['a', 'b']", "list[str]"),
+        ("[1, 'a']", "list[int | str]"),
+        ("[]", "list[]"),
+        ("{'a': 1}", "dict[str, int]"),
+        ("{'a': 1, 'b': 3.0}", "dict[str, float | int]"),
+        ("{}", "dict[]"),
+        ("(1, 'a')", "tuple[int, str]"),
+        ("()", "tuple[]"),
+    ],
+)
+def test_infer_type_constants(content, expected_type):
+    node = ast.parse(content).body[0].value
+    assert str(infer_type(node)) == expected_type
+
+
+@pytest.mark.parametrize(
+    "content, var_types, expected_type", [
+        ("foo", {}, "var:foo"),
+        ("foo", {"foo": "int"}, "int"),
+        ("func()", {}, "unknown"),
+    ],
+)
+def test_infer_type_variables(content, var_types, expected_type):
+    node = ast.parse(content).body[0].value
+    assert str(infer_type(node, var_types)) == expected_type
+
+
+@pytest.mark.parametrize(
+    "content, module_name, expected_aliases, expected_imports", [
+        ("import foo", "foo", {"foo"}, {}),
+        ("import foo as f", "foo", {"f"}, {}),
+        (
+            "from foo import bar, baz", "foo",
+            set(), {"bar": "bar", "baz": "baz"},
+        ),
+        (
+            "from foo import bar as b, baz", "foo",
+            set(), {"b": "bar", "baz": "baz"},
+        ),
+        ("import unrelated", "foo", set(), {}),
+        ("from unrelated import something", "foo", set(), {}),
+    ],
+)
+def test_find_import_aliases(content, module_name, expected_aliases, expected_imports):
+    tree = ast.parse(content)
+    module_aliases, direct_imports = find_import_aliases(tree, module_name)
+
+    assert module_aliases == expected_aliases
+    assert direct_imports == expected_imports
+
+
+def test_library_call_visitor_module_alias():
+    content = """
+import foo as f
+f.bar([1, 2, 3])
+f.baz("hello")
+"""
+    tree = ast.parse(content)
+
+    lib_aliases = {"f"}
+    direct_imports = {}
+    visitor = ModuleCallVisitor(lib_aliases, direct_imports)
+    visitor.visit(tree)
+
+    # Convert to string representation for comparison
+    calls_str = [
+        (func, pos, str(arg_type))
+        for func, pos, arg_type in visitor.calls
+    ]
+    assert ("bar", 0, "list[int]") in calls_str
+    assert ("baz", 0, "str") in calls_str
+
+
+def test_library_call_visitor_direct_import():
+    content = """
+from foo import bar, baz as b
+bar({'x': 1})
+b(42)
+"""
+    tree = ast.parse(content)
+
+    lib_aliases = set()
+    direct_imports = {"bar": "bar", "b": "baz"}
+    visitor = ModuleCallVisitor(lib_aliases, direct_imports)
+    visitor.visit(tree)
+
+    # Convert to string representation for comparison
+    calls_str = [
+        (func, pos, str(arg_type))
+        for func, pos, arg_type in visitor.calls
+    ]
+    assert ("bar", 0, "dict[str, int]") in calls_str
+    assert ("baz", 0, "int") in calls_str
+
+
+def test_library_call_visitor_multiple_args():
+    content = """
+import foo as f
+my_var = "hello"
+f.bar([1, 2], 80, my_var)
+"""
+    tree = ast.parse(content)
+
+    lib_aliases = {"f"}
+    direct_imports = {}
+    visitor = ModuleCallVisitor(lib_aliases, direct_imports)
+    visitor.visit(tree)
+
+    # Convert to string representation for comparison
+    calls_str = [
+        (func, pos, str(arg_type))
+        for func, pos, arg_type in visitor.calls
+    ]
+    assert ("bar", 0, "list[int]") in calls_str
+    assert ("bar", 1, "int") in calls_str
+    assert ("bar", 2, "str") in calls_str
+
+
+def test_analyze_file_simple(tmp_file):
+    content = """
+import foo as f
+from foo import bar
+
+def example():
+    data = [{"x": 1}, {"y": 2}]
+    f.bar(data, 40)
+    bar("string")
+    bar(123)
+    bar([1, 2, 3])
+
+my_list = [1, 2, 3]
+f.bar(my_list)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'foo')
+
+    assert usages["bar"][0] == {
+        'int',
+        'list[dict[str, int]]',
+        'list[int]',
+        'str',
+    }
+
+    assert usages["bar"][1] == {"int"}
+
+
+def test_dict_expansion(tmp_file):
+    content = """
+import f
+
+dd = {'a': 5.0}
+dd2 = {'b': 1, **dd}
+dd3 = {'c': True, **dd2}
+dd4 = {**dd3}
+f.foo(dd2)
+f.bar(dd3)
+f.foobar(dd4)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    assert usages["foo"][0] == {'dict[str, float | int]'}
+    assert usages["bar"][0] == {'dict[str, bool | float | int]'}
+    assert usages["foobar"][0] == {'dict[str, bool | float | int]'}
+
+
+def test_list_unpacking(tmp_file):
+    content = """
+import f
+
+a = [1, 2]
+b = [*a, 3.0, "x"]
+c = ["y", *a]
+f.foo(b)
+f.bar(c)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    assert usages["foo"][0] == {'list[float | int | str]'}
+    assert usages["bar"][0] == {'list[int | str]'}
+
+
+def test_tuple_unpacking(tmp_file):
+    content = """
+import f
+
+a = (1, 2)
+b = (*a, 3.0, "x")
+c = ("y", *a)
+f.foo(b)
+f.bar(c)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    assert usages["foo"][0] == {'tuple[int, int, float, str]'}
+    assert usages["bar"][0] == {'tuple[str, int, int]'}
+
+
+def test_mixed_unpacking(tmp_file):
+    content = """
+import f
+
+a = [1, 2]
+b = (3.0, "x")
+c = [*a, *b, True]
+d = (*a, *b, False)
+f.foo(c)
+f.bar(d)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    assert usages["foo"][0] == {'list[bool | float | int | str]'}
+    assert usages["bar"][0] == {'tuple[bool | float | int | str]'}
+
+
+def test_exact_tuple_unpacking(tmp_file):
+    content = """
+import f
+
+# Exact cases - tuple variables and literals give exact positional types
+t1 = (1, "x")
+t2 = (*t1, 3.0)          # tuple variable expansion - exact
+t3 = (*(1, "x"), 3.0)    # tuple literal expansion - exact
+
+f.exact1(t2)
+f.exact2(t3)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    # Exact positional types (comma-separated)
+    assert usages["exact1"][0] == {'tuple[int, str, float]'}
+    assert usages["exact2"][0] == {'tuple[int, str, float]'}
+
+
+def test_inexact_list_to_tuple_unpacking(tmp_file):
+    content = """
+import f
+
+# Inexact cases - list variables give union types
+l1 = [1, 2]
+t4 = (*l1, "x")          # list variable expansion - inexact
+
+f.inexact(t4)
+"""
+
+    tmp_file.write_text(content)
+    usages = analyze_file(tmp_file, 'f')
+
+    # Inexact union types (pipe-separated)
+    assert usages["inexact"][0] == {'tuple[int | str]'}

typespy-0.1.0/typespy.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: typespy
+Version: 0.1.0
+Summary: Detect python calling types
+Author: Rasmus Nygren
+Maintainer: Rasmus Nygren
+Project-URL: Homepage, https://github.com/rasmusnygren/typespy
+Project-URL: Repository, https://github.com/rasmusnygren/typespy
+Keywords: type detection,type tracing,typing
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+Typespy
+=======
+Figure out which types your modules are being called with.
+
+## Installation
+```bash
+pip install typespy
+```
+
+## Usage
+```bash
+usage: typespy [-h] [--verbose] module_names [module_names ...] dir
+
+Analyze function call type information
+
+positional arguments:
+  module_names  Name of the modules to analyze
+  dir           Path to the root directory of repositories
+
+options:
+  -h, --help    show this help message and exit
+  --verbose     Print function calls with file locations
+```

typespy-0.1.0/typespy.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+typespy.py
+tests/test_analyze.py
+typespy.egg-info/PKG-INFO
+typespy.egg-info/SOURCES.txt
+typespy.egg-info/dependency_links.txt
+typespy.egg-info/entry_points.txt
+typespy.egg-info/top_level.txt

typespy-0.1.0/typespy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

typespy-0.1.0/typespy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+typespy = typespy:main

typespy-0.1.0/typespy.egg-info/top_level.txt

@@ -0,0 +1 @@
+typespy

typespy-0.1.0/typespy.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import argparse
+import ast
+import os
+from collections import defaultdict
+from collections.abc import Collection
+from typing import NamedTuple
+from typing import TypeAlias
+
+ModuleUsageTypes: TypeAlias = dict[str, dict[int, set[str]]]
+
+
+class ListType(NamedTuple):
+    element_types: frozenset[InferredType] = frozenset()
+
+    def __str__(self) -> str:
+        if not self.element_types:
+            return "list[]"
+        return f"list[{' | '.join(sorted(str(x) for x in self.element_types))}]"
+
+    @classmethod
+    def from_set(cls, s: set[InferredType]) -> ListType:
+        return cls(element_types=frozenset(s))
+
+
+class TupleType(NamedTuple):
+    element_types: tuple[InferredType, ...] = ()
+    # Use union types if it's not possible to determine
+    # the # of args and their exact type by position
+    use_union_types: bool = False
+
+    def __str__(self) -> str:
+        if self.use_union_types:
+            unique_types = sorted({str(x) for x in self.element_types})
+            return f"tuple[{' | '.join(unique_types)}]"
+        else:
+            return f"tuple[{', '.join(str(x) for x in self.element_types)}]"
+
+
+class DictType(NamedTuple):
+    key_types: frozenset[InferredType] = frozenset()
+    value_types: frozenset[InferredType] = frozenset()
+
+    def __str__(self) -> str:
+        if not self.key_types and not self.value_types:
+            return "dict[]"
+        key_type = ' | '.join(sorted(str(x) for x in self.key_types))
+        value_type = ' | '.join(sorted(str(x) for x in self.value_types))
+        return f"dict[{key_type}, {value_type}]"
+
+    @classmethod
+    def from_sets(cls, keys: set[InferredType], values: set[InferredType]) -> DictType:
+        return cls(key_types=frozenset(keys), value_types=frozenset(values))
+
+
+class VarType(NamedTuple):
+    name: str
+
+    def __str__(self) -> str:
+        return f"var:{self.name}"
+
+
+InferredType = str | ListType | TupleType | DictType | VarType
+
+
+def _extract_collection_types(inferred_type: InferredType) -> Collection[InferredType]:
+    if isinstance(inferred_type, (ListType, TupleType)):
+        return inferred_type.element_types
+    return [inferred_type]
+
+
+def _infer_list_type(node: ast.List, var_types: dict[str, InferredType] | None = None) -> ListType:
+    if not node.elts:
+        return ListType()
+
+    element_types: set[InferredType] = set()
+
+    for elt in node.elts:
+        if isinstance(elt, ast.Starred):
+            expanded_type = infer_type(elt.value, var_types)
+            inner_types = _extract_collection_types(expanded_type)
+            element_types.update(inner_types)
+        else:
+            element_types.add(infer_type(elt, var_types))
+
+    return ListType.from_set(element_types)
+
+
+def _infer_tuple_type(
+    node: ast.Tuple, var_types: dict[str, InferredType] | None = None,
+) -> TupleType:
+    """
+    If we can infer the exact number of arguments and types of the tuple
+    arguments then return an exact representation (tuple[int, int, int, str])
+    whereas if we can't, then return a unionized representation of the
+    tuple types (tuple[int | str]).
+    """
+    if not node.elts:
+        return TupleType()
+
+    tuple_types = []
+    use_union_types = False
+
+    for elt in node.elts:
+        if isinstance(elt, ast.Starred):
+            if isinstance(elt.value, (ast.List, ast.Tuple)):
+                for sub_elt in elt.value.elts:
+                    tuple_types.append(infer_type(sub_elt, var_types))
+            else:
+                expanded_type = infer_type(elt.value, var_types)
+                inner_types = _extract_collection_types(expanded_type)
+                tuple_types.extend(inner_types)
+                if isinstance(expanded_type, ListType):
+                    use_union_types = True
+        else:
+            tuple_types.append(infer_type(elt, var_types))
+
+    return TupleType(
+        element_types=tuple(tuple_types),
+        use_union_types=use_union_types,
+    )
+
+
+def _infer_dict_type(node: ast.Dict, var_types: dict[str, InferredType] | None = None) -> DictType:
+    if not node.keys and not node.values:
+        return DictType()
+
+    key_types: set[InferredType] = set()
+    value_types: set[InferredType] = set()
+
+    for key, value in zip(node.keys, node.values):
+        if key is None:
+            # If the key is None, we have a dict-unpacking expression (**dict)
+            # and need to recursively infer the inner types and determine
+            # if they are part of the key types or value types.
+            expanded_type = infer_type(value, var_types)
+            if isinstance(expanded_type, DictType):
+                key_types.update(expanded_type.key_types)
+                value_types.update(expanded_type.value_types)
+
+        else:
+            key_types.add(infer_type(key, var_types))
+            value_types.add(infer_type(value, var_types))
+
+    return DictType.from_sets(key_types, value_types)
+
+
+def infer_type(node: ast.AST, var_types: dict[str, InferredType] | None = None) -> InferredType:
+    if isinstance(node, ast.Constant):
+        return type(node.value).__name__
+    elif isinstance(node, ast.List):
+        return _infer_list_type(node, var_types)
+    elif isinstance(node, ast.Dict):
+        return _infer_dict_type(node, var_types)
+    elif isinstance(node, ast.Tuple):
+        return _infer_tuple_type(node, var_types)
+    elif isinstance(node, ast.Name):
+        if var_types and node.id in var_types:
+            return var_types[node.id]
+        return VarType(node.id)
+    return "unknown"
+
+
+def find_import_aliases(
+    tree: ast.AST,
+    module_name: str,
+) -> tuple[set[str], dict[str, str]]:
+    module_aliases: set[str] = set()
+    direct_imports: dict[str, str] = {}
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == module_name:
+                    module_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module and node.module.startswith(module_name):
+                for alias in node.names:
+                    local_name = alias.asname or alias.name
+                    direct_imports[local_name] = alias.name
+
+    return module_aliases, direct_imports
+
+
+class ModuleCallVisitor(ast.NodeVisitor):
+    def __init__(
+        self,
+        lib_aliases: set[str],
+        direct_imports: dict[str, str],
+        filepath: str | None = None,
+        verbose: bool = False,
+    ) -> None:
+        self.lib_aliases = lib_aliases
+        self.direct_imports = direct_imports
+        self.filepath = filepath
+        self.verbose = verbose
+        self.calls: list[tuple[str, int, InferredType]] = []
+        self.var_types: dict[str, InferredType] = {}
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            var_name = node.targets[0].id
+            var_type = infer_type(node.value, self.var_types)
+            if not isinstance(var_type, VarType):
+                self.var_types[var_name] = var_type
+
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        func_name: str | None = None
+
+        if (
+            isinstance(node.func, ast.Attribute)
+            and isinstance(node.func.value, ast.Name)
+        ):
+            if node.func.value.id in self.lib_aliases:
+                func_name = node.func.attr
+
+        elif isinstance(node.func, ast.Name) and node.func.id in self.direct_imports:
+            func_name = self.direct_imports[node.func.id]
+
+        if func_name:
+            arg_types: list[InferredType] = []
+            for i, arg in enumerate(node.args):
+                arg_type = infer_type(arg, self.var_types)
+                arg_types.append(arg_type)
+                self.calls.append((func_name, i, arg_type))
+
+            if self.verbose:
+                args_str = ', '.join(str(t) for t in arg_types)
+                print(
+                    f"[{self.filepath}:{node.lineno}] {func_name}({args_str})",
+                )
+
+        self.generic_visit(node)
+
+
+def analyze_file(filepath: str, module_name: str, verbose: bool = False) -> ModuleUsageTypes:
+    with open(filepath, encoding="utf-8") as f:
+        source = f.read()
+    tree = ast.parse(source, filename=filepath)
+    module_aliases, direct_imports = find_import_aliases(tree, module_name)
+
+    usages: ModuleUsageTypes = defaultdict(lambda: defaultdict(set))
+    if module_aliases or direct_imports:
+        visitor = ModuleCallVisitor(
+            module_aliases, direct_imports, filepath, verbose,
+        )
+        visitor.visit(tree)
+        for func_name, arg_pos, arg_type in visitor.calls:
+            usages[func_name][arg_pos].add(str(arg_type))
+
+    return usages
+
+
+def walk_repo(
+    root_dir: str,
+    module_name: str,
+    verbose: bool = False,
+) -> ModuleUsageTypes:
+    usages: ModuleUsageTypes = defaultdict(lambda: defaultdict(set))
+    for dirpath, _, filenames in os.walk(root_dir):
+        filenames = [x for x in filenames if x.endswith(".py")]
+        for filename in filenames:
+            for func_name, args_data in analyze_file(
+                    os.path.join(dirpath, filename),
+                    module_name, verbose,
+            ).items():
+                for arg_pos, types in args_data.items():
+                    usages[func_name][arg_pos].update(types)
+    return usages
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Analyze function call type information",
+    )
+    parser.add_argument(
+        "module_names", nargs="+",
+        help="Name of the modules to analyze",
+    )
+    parser.add_argument(
+        "dir", help="Path to the root directory of repositories",
+    )
+    parser.add_argument(
+        "--verbose", action="store_true",
+        help="Print function calls with file locations",
+    )
+    args = parser.parse_args()
+
+    module_usages: dict[str, ModuleUsageTypes] = {}
+
+    for module in args.module_names:
+        usages = walk_repo(
+            args.dir, module, verbose=args.verbose,
+        )
+        module_usages[module] = usages
+
+    for module, usages in module_usages.items():
+        print(f"=== Module <{module}> summary ===")
+        for func, args_types in usages.items():
+            print(f"Function: {func}")
+            for pos, types in args_types.items():
+                print(f"  Arg {pos}: {', '.join(sorted(types))}")
+            print()
+    return 0
+
+
+if __name__ == "__main__":
+    SystemExit(main())