Typhon-Language 0.1.3__tar.gz → 0.1.4__tar.gz

typhon_language-0.1.4/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025- Hirofumi Nakamura
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{typhon_language-0.1.3/src/Typhon_Language.egg-info → typhon_language-0.1.4}/PKG-INFO

@@ -1,16 +1,18 @@
 Metadata-Version: 2.4
 Name: Typhon-Language
-Version: 0.1.3
+Version: 0.1.4
 Summary: Typhon programming language
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: basedpyright>=1.32.1
+Requires-Dist: basedpyright>=1.37.1
 Requires-Dist: fire>=0.7.1
-Requires-Dist: intervaltree>=3.1.0
+Requires-Dist: intervaltree>=3.2.1
 Requires-Dist: pegen>=0.3.0
-Requires-Dist: pytest>=8.4.1
-Requires-Dist: ruff>=0.12.5
+Requires-Dist: pygls>=2.0.0
+Requires-Dist: pyrefly>=0.47.0
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: ruff>=0.14.11
 Dynamic: license-file
 
 # Typhon

{typhon_language-0.1.3 → typhon_language-0.1.4}/pyproject.toml

@@ -1,16 +1,18 @@
 [project]
 name = "Typhon-Language"
-version = "0.1.3"
+version = "0.1.4"
 description = "Typhon programming language"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "basedpyright>=1.32.1",
+    "basedpyright>=1.37.1",
     "fire>=0.7.1",
-    "intervaltree>=3.1.0",
+    "intervaltree>=3.2.1",
     "pegen>=0.3.0",
-    "pytest>=8.4.1",
-    "ruff>=0.12.5",
+    "pygls>=2.0.0",
+    "pyrefly>=0.47.0",
+    "pytest>=9.0.2",
+    "ruff>=0.14.11",
 ]
 
 [project.scripts]

typhon_language-0.1.4/src/Typhon/Driver/configs.py

@@ -0,0 +1,14 @@
+from typing import Literal
+
+_language_backend: Literal["pyrefly", "pyright"] = "pyrefly"
+# TODO: Basedpyright seems to hang on semantic tokens request
+_language_backend = "pyright"
+
+
+def set_language_backend(backend: Literal["pyrefly", "pyright"]):
+    global _language_backend
+    _language_backend = backend
+
+
+def get_language_backend() -> Literal["pyrefly", "pyright"]:
+    return _language_backend

typhon_language-0.1.4/src/Typhon/Driver/debugging.py

@@ -0,0 +1,190 @@
+from .utils import copy_type, get_project_root
+from typing import BinaryIO, override
+from pathlib import Path
+import logging
+
+
+_debug = False
+_debug_verbose = False
+_debug_first_error = False
+_debug_log_file: Path | None = None
+
+
+def set_debug_mode(debug: bool):
+    global _debug
+    _debug = debug
+
+
+def set_debug_verbose(verbose: bool):
+    global _debug_verbose
+    _debug_verbose = verbose
+    if verbose:
+        set_debug_mode(True)
+
+
+def set_debug_first_error(first_error: bool):
+    global _debug_first_error
+    _debug_first_error = first_error
+
+
+def set_debug_log_file(
+    log_file: str | None, verbose: bool = False, append: bool = False
+):
+    global _debug_log_file
+    _debug_log_file = Path(log_file) if log_file else None
+    if _debug_log_file is not None:
+        if verbose:
+            set_debug_verbose(True)
+        set_debug_mode(True)
+        mode = "a" if append else "w"
+        with _debug_log_file.open(mode) as f:
+            f.write("=== Typhon Debug Log ===\n")
+
+
+def is_debug_mode() -> bool:
+    return _debug
+
+
+def is_debug_verbose() -> bool:
+    return _debug_verbose
+
+
+# Whether to stop transformation at the first error encountered.
+def is_debug_first_error() -> bool:
+    return _debug_first_error
+
+
+def get_debug_log_file() -> Path | None:
+    return _debug_log_file
+
+
+_debug_printed: int = 0
+_debug_printed_size: int = 0
+_limit_reached_printed: bool = False
+
+
+def _debug_limit_check(*arg) -> bool:
+    global _debug_printed
+    global _debug_printed_size
+    global _limit_reached_printed
+    if _debug_printed > 100000 or _debug_printed_size > 10000000:
+        if not _limit_reached_printed:
+            print("Debug print limit reached, stopping further debug prints.")
+            _limit_reached_printed = True
+        return True
+    _debug_printed += 1
+    _debug_printed_size += sum(len(str(a)) for a in arg)
+    return False
+
+
+@copy_type(print)
+def debug_print(*arg, **kwargs) -> None:  # type: ignore
+    if _debug:
+        if _debug_limit_check(*arg):
+            return
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+        else:
+            print(*arg, **kwargs)  # type: ignore
+
+
+@copy_type(print)
+def debug_verbose_print(*arg, **kwargs) -> None:  # type: ignore
+    if _debug_verbose:
+        if _debug_limit_check(*arg):
+            return
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+        else:
+            print(*arg, **kwargs)  # type: ignore
+
+
+@copy_type(print)
+def debug_file_write(*arg, **kwargs) -> None:  # type: ignore
+    if _debug:
+        if _debug_log_file is not None:
+            if _debug_limit_check(*arg):
+                return
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+
+
+@copy_type(print)
+def debug_file_write_verbose(*arg, **kwargs) -> None:  # type: ignore
+    if _debug_verbose:
+        if _debug_log_file is not None:
+            if _debug_limit_check(*arg):
+                return
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+
+
+type ReadableBuffer = bytes | bytearray | memoryview
+
+
+# Bypass binaryIO class stdio to log
+class BinaryIOLogger(BinaryIO):
+    def __init__(self, pipe: BinaryIO):
+        self._pipe = pipe
+
+    def fileno(self) -> int:
+        return self._pipe.fileno()
+
+    def isatty(self) -> bool:
+        return self._pipe.isatty()
+
+    def write(self, data: ReadableBuffer) -> int:
+        # Log the data being written
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Writing {data}\n")
+                log_file.flush()
+        return self._pipe.write(data)
+
+    def flush(self) -> None:
+        self._pipe.flush()
+
+    def read(self, n: int = -1) -> bytes:
+        data = self._pipe.read(n)
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Read {data}\n")
+                log_file.flush()
+        return data
+
+    def close(self) -> None:
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write("Closing pipe.\n")
+                log_file.flush()
+        self._pipe.close()
+
+    @override
+    def readline(self, limit: int = -1) -> bytes:
+        line = self._pipe.readline(limit)
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Read line {line}\n")
+                log_file.flush()
+        return line
+
+
+def debug_setup_logging(verbose: bool = True, append: bool = False) -> None:
+    set_debug_log_file(
+        str(get_project_root() / "private" / "server1.log"),
+        verbose=verbose,
+        append=append,
+    )
+    set_debug_mode(True)
+    set_debug_verbose(verbose)
+    if (log_file := get_debug_log_file()) is not None:
+        logging.basicConfig(
+            filename=log_file,
+            level=logging.INFO if verbose else logging.DEBUG,
+            filemode="a",
+            format="%(asctime)s %(levelname)s %(name)s %(message)s",
+            force=True,
+        )
+    debug_file_write("=== Typhon Debug Logging set ===\n")

{typhon_language-0.1.3 → typhon_language-0.1.4}/src/Typhon/Driver/diagnostic.py

@@ -9,8 +9,9 @@ def diag_error_file_position(
     rule: str | None,
     message: str,
 ):
+    # Range is 0-based, but line numbers displayed are 1-based
     return (
-        f"{error_type}: {file_path}:{position.start.line}:{position.start.column}{rule if rule else ''}\n"
+        f"{error_type}: {file_path}:{position.start.line + 1}:{position.start.column + 1}{rule if rule else ''}\n"
         f"  {message}"
     )
 
@@ -22,8 +23,8 @@ def positioned_source_code(
     result = ""
     len_in_digit = len(str(range_in_source.end.line)) + 1
     for line_num in range(range_in_source.start.line, range_in_source.end.line + 1):
-        if line_num >= 1 and line_num <= len(source_lines):
-            result += f"    {line_num:<{len_in_digit}}|  {source_lines[line_num - 1]}\n"
+        if line_num >= 0 and line_num < len(source_lines):
+            result += f"    {line_num + 1:<{len_in_digit}}|  {source_lines[line_num]}\n"
             if (
                 range_in_source.start.line == range_in_source.end.line
                 and line_num == range_in_source.start.line

typhon_language-0.1.4/src/Typhon/Driver/language_server.py

@@ -0,0 +1,25 @@
+from ..LanguageServer import server
+from ..Driver.debugging import (
+    is_debug_mode,
+    BinaryIOLogger,
+    set_debug_log_file,
+    debug_print,
+    get_debug_log_file,
+    set_debug_verbose,
+    debug_setup_logging,
+)
+import sys
+import logging
+
+
+def language_server():
+    """
+    Start the Typhon Language Server.
+    """
+    server.start_io(
+        stdin=BinaryIOLogger(sys.stdin.buffer),
+        stdout=BinaryIOLogger(sys.stdout.buffer),
+    )
+
+    # TODO: Support TCP Mode?
+    # server.start_tcp("127.0.0.1", 8080)

{typhon_language-0.1.3 → typhon_language-0.1.4}/src/Typhon/Driver/run.py

@@ -92,7 +92,7 @@ def run_directory(source_dir: Path, capture_output: bool, *args: str) -> RunResu
     # Set up environment with modified PYTHONPATH
     orig_pythonpath = os.environ.get("PYTHONPATH", "")
     if orig_pythonpath:
-        orig_pythonpath = f":{orig_pythonpath}"
+        orig_pythonpath = f"{os.pathsep}{orig_pythonpath}"
     subprocess_env = {
         **dict(os.environ),
         # Override PYTHONPATH to include temp_output_dir

{typhon_language-0.1.3 → typhon_language-0.1.4}/src/Typhon/Driver/translate.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from ..Grammar.parser import parse_file
 from ..Grammar.syntax_errors import (
     diag_errors,
-    TyphonSyntaxError,
+    TyphonTransformSyntaxError,
     TyphonSyntaxErrorList,
 )
 from ..Grammar.unparse_custom import unparse_custom
@@ -15,12 +15,13 @@ from .utils import (
     copy_type,
     default_output_dir,
     canonicalize_path,
+    mkdir_and_setup_init_py,
 )
 from ..Transform.transform import transform
 from .debugging import is_debug_mode, debug_print, is_debug_verbose
 from ..Driver.type_check import run_type_check, TypeCheckResult
 from ..SourceMap import SourceMap
-from ..SourceMap.ast_match_based_map import map_from_transformed_ast
+from ..SourceMap.ast_match_based_map import map_from_translated_ast
 
 
 @dataclass
@@ -28,7 +29,9 @@ class TranslateResult:
     source_path_canonical: str
     output_path_canonical: str
     source_map: SourceMap | None
-    syntax_error: SyntaxError | TyphonSyntaxError | TyphonSyntaxErrorList | None
+    syntax_error: (
+        SyntaxError | TyphonTransformSyntaxError | TyphonSyntaxErrorList | None
+    )
 
 
 def translate_file(source: Path, output: Path) -> TranslateResult:
@@ -36,7 +39,7 @@ def translate_file(source: Path, output: Path) -> TranslateResult:
     try:
         ast_tree = parse_file(source.as_posix(), verbose=is_debug_verbose())
         transform(ast_tree)
-    except (SyntaxError, TyphonSyntaxError, TyphonSyntaxErrorList) as e:
+    except (SyntaxError, TyphonTransformSyntaxError, TyphonSyntaxErrorList) as e:
         debug_print(f"Error parsing file {source}: {e}")
         return TranslateResult(
             source_path_canonical=canonicalize_path(source),
@@ -46,8 +49,12 @@ def translate_file(source: Path, output: Path) -> TranslateResult:
         )
     translated_code = unparse_custom(ast_tree)
     source_code = source.read_text(encoding="utf-8")
-    mapping = map_from_transformed_ast(
-        ast_tree, ast.parse(translated_code), source_code, source.as_posix()
+    mapping = map_from_translated_ast(
+        ast_tree,
+        ast.parse(translated_code),
+        source_code,
+        source.as_posix(),
+        translated_code,
     )
     output.write_text(translated_code)
     return TranslateResult(
@@ -96,10 +103,7 @@ def translate_directory(
         output_path = module_output_dir / (source.stem + ".py")
         file_result = translate_file(source, output_path)
         result[source] = file_result
-    if not (module_output_dir / "__init__.py").exists():
-        (module_output_dir / "__init__.py").write_text(
-            "# Init file for Typhon module\n", "utf-8"
-        )
+    mkdir_and_setup_init_py(module_output_dir)
     for subdir in source_dir.iterdir():
         if subdir.is_dir():
             sub_output_dir = module_output_dir / subdir.name

{typhon_language-0.1.3 → typhon_language-0.1.4}/src/Typhon/Driver/utils.py

@@ -4,6 +4,8 @@ import os
 
 
 TYPHON_EXT = ".typh"
+TYPHON_TEMP_DIR = ".typhon"
+TYPHON_SERVER_TEMP_DIR = ".typhon-server"
 
 
 def shorthand[T](
@@ -29,7 +31,19 @@ def shorthand[T](
 
 
 def default_output_dir(source: str) -> Path:
-    return Path(source).parent / ".typhon"
+    return Path(source).parent / TYPHON_TEMP_DIR
+
+
+def output_dir_for_workspace(workspace: Path) -> Path:
+    return workspace / TYPHON_SERVER_TEMP_DIR
+
+
+def default_server_output_dir(source: str) -> Path:
+    return Path(source).parent / TYPHON_SERVER_TEMP_DIR
+
+
+def output_dir_for_server_workspace(workspace: Path) -> Path:
+    return workspace / TYPHON_SERVER_TEMP_DIR
 
 
 def prepare_default_output_file(source: Path) -> Path:
@@ -39,6 +53,21 @@ def prepare_default_output_file(source: Path) -> Path:
     return output_file
 
 
+def prepare_default_server_output_file(source: Path) -> Path:
+    temp_output_dir = default_server_output_dir(source.as_posix())
+    temp_output_dir.mkdir(exist_ok=True)
+    output_file = temp_output_dir / (source.stem + ".py")
+    return output_file
+
+
+def mkdir_and_setup_init_py(dir: Path) -> None:
+    if not dir.exists():
+        dir.mkdir(parents=True, exist_ok=True)
+    init_file = dir / "__init__.py"
+    if not init_file.exists():
+        init_file.write_text("# Init file_for Typhon module.", encoding="utf-8")
+
+
 def copy_type[**P, T](
     _: Callable[P, T],
 ) -> Callable[[Callable[..., T]], Callable[P, T]]:
@@ -52,3 +81,12 @@ def copy_type[**P, T](
 # For windows, convert all to lower case and resolve.
 def canonicalize_path(path: Path) -> str:
     return Path(os.path.normcase(str(path))).resolve().as_posix()
+
+
+def get_project_root() -> Path:
+    current = Path(__file__).resolve()
+    for _ in range(10):
+        if (current / "pyproject.toml").exists():
+            return current
+        current = current.parent
+    raise FileNotFoundError("Could not find project root with pyproject.toml")