♻️ Make code synchronous.

Author: rafalkrupinski

poetry.lock

@@ -33,7 +33,7 @@ packages = [{ include = "lapidary", from = "src" }]
 
 [tool.poetry.dependencies]
 python = "^3.13"
-asyncclick = "^8"
+click = "^8"
 httpx = "^0.28"
 libcst = "^1.5"
 openapi-pydantic = "^0.5"

pyproject.toml

@@ -1,8 +1,7 @@
 import sys
 from pathlib import Path
 
-import anyio
-import asyncclick as click
+import click
 
 
 @click.group()
@@ -18,12 +17,12 @@ def app(verbose: bool) -> None:
 
 @app.command()
 @click.argument('document')
-@click.argument('project_root')
+@click.argument('project_root', type=click.Path(path_type=Path, exists=False, file_okay=False, dir_okay=True))
 @click.argument('package_name')
 @click.option('--save/--no-save', help='Copy the document in the project', default=False)
-async def init(
+def init(
     document: str,
-    project_root: str,
+    project_root: Path,
     package_name: str,
     save: bool = False,
 ):
@@ -39,29 +38,33 @@ async def init(
     from .main import init_project
 
     try:
-        await init_project(document, anyio.Path(project_root), package_name, save)
+        init_project(document, project_root, package_name, save)
     except FileExistsError:
         raise click.ClickException('Target exists')
 
 
 @app.command()
-@click.argument('project_root', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.')
-async def render(
+@click.argument(
+    'project_root', type=click.Path(path_type=Path, exists=True, file_okay=False, dir_okay=True), default='.'
+)
+def render(
     project_root: Path = Path(),
 ) -> None:
     """Generate Python code"""
     from .main import render_project
 
-    await render_project(anyio.Path(project_root))
+    render_project(project_root)
 
 
 @app.command(hidden=True)
-@click.argument('project_root', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.')
+@click.argument(
+    'project_root', type=click.Path(path_type=Path, exists=True, file_okay=False, dir_okay=True), default='.'
+)
 @click.option('--process', is_flag=True, help='Output processed python model', default=False)
-async def dump_model(
+def dump_model(
     project_root: Path = Path(),
     process: bool = False,
 ) -> None:
     from .main import dump_model as dump_model_
 
-    await dump_model_(anyio.Path(project_root), process, sys.stdout)
+    dump_model_(project_root, process, sys.stdout)

src/lapidary/render/cli.py

@@ -1,22 +1,21 @@
 import tomllib
-from collections.abc import Sequence
+from pathlib import Path
 
-import anyio
 import pydantic
 
 PYPROJ_TOML = 'pyproject.toml'
 
 
 class Config(pydantic.BaseModel):
-    document_path: str | None = None
+    document_path: str
     """URL or path relative to ./openapi/"""
     origin: pydantic.AnyHttpUrl | None = None
     """Origin URL in case"""
     package: str
 
 
-async def load_config(project_root: anyio.Path) -> Config:
-    text = await (project_root / PYPROJ_TOML).read_text()
+def load_config(project_root: Path) -> Config:
+    text = (project_root / PYPROJ_TOML).read_text()
     pyproj = tomllib.loads(text)
     pyproj_dict = pyproj['tool']['lapidary']
     return Config.model_validate(pyproj_dict)

src/lapidary/render/config.py

@@ -1,8 +1,8 @@
 import abc
 import logging
 from collections.abc import Mapping
+from pathlib import Path
 
-import anyio
 import httpx
 import ruamel.yaml
 
@@ -11,21 +11,21 @@
 logger = logging.getLogger(__name__)
 
 
-async def load_document(root: anyio.Path, config: Config) -> Mapping:
+def load_document(root: Path, config: Config) -> Mapping:
     logger.info('Load OpenAPI document')
 
     yaml = ruamel.yaml.YAML(typ='safe')
 
-    text = await document_handler_for(root, config.document_path).load()
+    text = document_handler_for(root, config.document_path).load()
     return yaml.load(text)
 
 
-class DocumentHandler[P: str | anyio.Path](abc.ABC):
-    def __init__(self, path: P) -> None:
+class DocumentHandler(abc.ABC):
+    def __init__(self, path: str) -> None:
         self._path = path
 
     @abc.abstractmethod
-    async def load(self) -> str:
+    def load(self) -> str:
         """Return document text and, which could be URL path or local file path."""
 
     @property
@@ -38,42 +38,42 @@ def path(self) -> str:
         return str(self._path)
 
     @abc.abstractmethod
-    async def save_to(self, target: anyio.Path) -> str:
+    def save_to(self, target: Path) -> str:
         """Save the document.
         :param target: target directory
         :return: file name of the saved document"""
 
 
-class FileDocumentHandler(DocumentHandler[anyio.Path]):
-    def __init__(self, project_root: anyio.Path, path: anyio.Path) -> None:
-        assert isinstance(project_root, anyio.Path)
-        assert isinstance(path, anyio.Path)
+class FileDocumentHandler(DocumentHandler):
+    def __init__(self, project_root: Path, path: str) -> None:
+        assert isinstance(project_root, Path)
         super().__init__(path)
         self._project_root = project_root
 
-    async def load(self) -> str:
-        return await (self._project_root / self._path).read_text()
+    def load(self) -> str:
+        return (self._project_root / self._path).read_text()
 
-    async def save_to(self, target: anyio.Path) -> str:
+    def save_to(self, target: Path) -> str:
         import shutil
 
-        shutil.copyfile(self._path, target / self._path.name)
-        return self._path.name
+        src_path = Path(self._path)
+        shutil.copyfile(self._path, target / src_path.name)
+        return src_path.name
 
     @property
     def is_url(self) -> bool:
         return False
 
 
-class HttpDocumentHandler(DocumentHandler[str]):
+class HttpDocumentHandler(DocumentHandler):
     def __init__(self, path: str) -> None:
         super().__init__(path)
-        self._client = httpx.AsyncClient(timeout=30.0)
+        self._client = httpx.Client(timeout=30.0)
         self._cache: str | None = None
 
-    async def load(self) -> str:
+    def load(self) -> str:
         if not self._cache:
-            response = await self._client.get(self._path)
+            response = self._client.get(self._path)
             self._cache = response.text
         assert self._cache is not None
         return self._cache
@@ -86,20 +86,19 @@ def _file_name(self) -> str:
         _, name = split(parsed.path)
         return name or 'openapi.yaml'
 
-    async def save_to(self, target: anyio.Path) -> str:
-        text = await self.load()
+    def save_to(self, target: Path) -> str:
+        text = self.load()
         file_name = self._file_name()
-        await (target / file_name).write_text(text)
+        (target / file_name).write_text(text)
         return file_name
 
     @property
     def is_url(self) -> bool:
         return True
 
 
-def document_handler_for(document_root: anyio.Path, path: str | anyio.Path) -> DocumentHandler:
-    match path:
-        case str() if path.startswith(('http://', 'https://')):
-            return HttpDocumentHandler(path)
-        case _:
-            return FileDocumentHandler(document_root, anyio.Path(path))
+def document_handler_for(document_root: Path, path: str) -> DocumentHandler:
+    if path.startswith(('http://', 'https://')):
+        return HttpDocumentHandler(path)
+    else:
+        return FileDocumentHandler(document_root, str(path))

src/lapidary/render/load.py

@@ -1,10 +1,9 @@
 import logging
-import pathlib
 from collections.abc import Mapping
+from pathlib import Path, PurePath
 from typing import TextIO
 
-import anyio
-import asyncclick as click
+import click
 import pydantic
 import ruamel.yaml
 
@@ -15,38 +14,38 @@
 logger = logging.getLogger(__name__)
 
 
-async def init_project(
+def init_project(
     document_path: str,
-    project_root: anyio.Path,
+    project_root: Path,
     package_name: str,
     save_document: bool,
 ) -> None:
     """Create project directory and pyproject file, download or copy the OpenAPI document"""
 
-    if await project_root.exists():
+    if project_root.exists():
         raise FileExistsError
 
     from .writer import init_project
 
-    document_handler = document_handler_for(anyio.Path(), document_path)
+    document_handler = document_handler_for(Path(), document_path)
 
     if save_document:
-        document_root = anyio.Path('lapidary/openapi')
+        document_root = Path('lapidary/openapi')
         target_dir = project_root / document_root
-        await target_dir.mkdir(parents=True)
-        file_name = await document_handler.save_to(target_dir)
+        target_dir.mkdir(parents=True)
+        file_name = document_handler.save_to(target_dir)
         config_document_path = str(document_root / file_name)
     else:
         logger.warning('Saving OpenAPI document is recommended for portable and repeatable builds')
         if not document_handler.is_url:
-            document_path_path = pathlib.PurePath(document_path)
+            document_path_path = PurePath(document_path)
             if not document_path_path.is_absolute():
                 # document path is a file outside of the project root.
                 # If it's relative, make it relative to the project root.
                 try:
                     config_document_path = str(document_path_path.relative_to(project_root, walk_up=True))
                 except ValueError:
-                    config_document_path = str(await anyio.Path.cwd() / document_path_path)
+                    config_document_path = str(Path.cwd() / document_path_path)
             else:
                 config_document_path = document_path
         else:
@@ -60,18 +59,18 @@ async def init_project(
     )
 
     yaml = ruamel.yaml.YAML(typ='safe')
-    document = yaml.load(await document_handler.load())
+    document = yaml.load(document_handler.load())
 
-    await init_project(project_root, config, document)
+    init_project(project_root, config, document)
 
 
-async def render_project(project_root: anyio.Path) -> None:
+def render_project(project_root: Path) -> None:
     from .writer import update_project
 
-    config = await load_config(project_root)
+    config = load_config(project_root)
 
     logger.info('Parse OpenAPI document')
-    oa_doc = await load_document(project_root, config)
+    oa_doc = load_document(project_root, config)
     model = prepare_python_model(oa_doc, config)
 
     logger.info('Render project')
@@ -85,17 +84,17 @@ async def render_project(project_root: anyio.Path) -> None:
         def progress(module: python.AbstractModule) -> None:
             progressbar.update(1, module)
 
-        await update_project(
+        update_project(
             model.modules,
             project_root / 'src',
             config.package,
             progress,
         )
 
 
-async def dump_model(project_root: anyio.Path, process: bool, output: TextIO):
-    config = await load_config(project_root)
-    oa_doc = await load_document(project_root, config)
+def dump_model(project_root: Path, process: bool, output: TextIO):
+    config = load_config(project_root)
+    oa_doc = load_document(project_root, config)
     yaml = ruamel.yaml.YAML(typ='safe')
 
     if not process: