Replace mypy with pyright

.github/workflows/main.yml

@@ -30,8 +30,8 @@ jobs:
       - name: build
         run: make
 
-      - name: mypy
-        run: make mypy
+      - name: check-types
+        run: make check-types
 
       - name: tests
         run: env TOX_PARALLEL_NO_SPINNER=1 make test

Dockerfile

@@ -1,4 +1,4 @@
-FROM andreyfedoseev/django-static-precompiler:20.04-1
+FROM andreyfedoseev/django-static-precompiler:22.04-1
 ARG DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
 RUN apt update && \
@@ -7,6 +7,7 @@ RUN apt update && \
     apt install -y  \
     python3-venv \
     python3.8-dev \
+    python3.8-distutils \
     python3.9-dev \
     python3.9-distutils \
     python3.10-dev \
@@ -25,6 +26,7 @@ RUN python3 -m venv $POETRY_HOME && \
 RUN mkdir /app
 WORKDIR /app
 ADD poetry.lock pyproject.toml /app/
-RUN poetry install --all-extras --no-root --no-interaction
+RUN poetry install --all-extras --no-root --no-interaction && \
+    pyright --version #  this is to force pyright to install its dependencies
 ADD . /app/
 RUN poetry install --all-extras --no-interaction

Dockerfile-base

@@ -1,4 +1,4 @@
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 MAINTAINER Andrey Fedoseev <andrey@andreyfedoseev.com>
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt update && apt install -y autoconf libtool npm wget

Makefile

@@ -7,8 +7,8 @@ shell:
 test:
 	docker compose run --rm app tox -p auto
 
-mypy:
-	docker compose run --rm app mypy --strict ./src
+check-types:
+	docker compose run --rm app pyright
 
 package:
 	rm -rf ./dist

pyproject.toml

@@ -27,11 +27,11 @@ packages = [
     {include = "static_precompiler", from = "src"}
 ]
 include = [
-    "AUTHORS",
-    "README.md",
-    "CHANGES.md",
-    "LICENSE",
-    "py.typed",
+    {path = "AUTHORS"},
+    {path = "README.md"},
+    {path = "CHANGES.md"},
+    {path = "LICENSE"},
+    {path = "py.typed"},
     { path = "tests", format = "sdist" }
 ]
 
@@ -50,8 +50,8 @@ pytest-cov = "~4.0.0"
 watchdog = "~3.0.0"
 coverage = "~7.3.0"
 tox = "~4.9.0"
-mypy = "~1.4.0"
-django-stubs = {extras = ["compatible-mypy"], version = "~4.2.3"}
+pyright = "^1.1.323"
+django-stubs = "~4.2.3"
 
 [tool.poetry.extras]
 libsass = ["libsass"]
@@ -73,13 +73,7 @@ target-version = "py38"
 [tool.ruff.isort]
 known-first-party = ["static_precompiler"]
 
-[tool.mypy]
-python_version = "3.8"
-plugins = ["mypy_django_plugin.main"]
-
-[[tool.mypy.overrides]]
-module = "pretend"
-ignore_missing_imports = true
-
-[tool.django-stubs]
-django_settings_module = "static_precompiler.mypy_django_settings"
+[tool.pyright]
+include = ["src"]
+exclude = ["__pycache__"]
+pythonVersion = "3.8"

src/static_precompiler/caching.py

@@ -3,24 +3,22 @@
 from typing import Optional
 
 import django.core.cache
-import django.utils.encoding
-from django.core.cache import BaseCache
 
 from . import settings
 
 
-def get_cache() -> BaseCache:
+def get_cache() -> django.core.cache.BaseCache:
     if settings.CACHE_NAME:
         return django.core.cache.caches.get(settings.CACHE_NAME)  # type: ignore
-    return django.core.cache.cache
+    return django.core.cache.cache  # type: ignore
 
 
 def get_cache_key(key: str) -> str:
     return f"static_precompiler.{socket.gethostname()}.{key}"
 
 
 def get_hexdigest(plaintext: str, length: Optional[int] = None) -> str:
-    digest = hashlib.md5(django.utils.encoding.smart_bytes(plaintext)).hexdigest()
+    digest = hashlib.md5(plaintext.encode()).hexdigest()
     if length:
         return digest[:length]
     return digest

src/static_precompiler/compilers/base.py

@@ -50,7 +50,7 @@ def get_full_source_path(self, source_path: str) -> str:
                 return full_path
 
         with contextlib.suppress(django.core.exceptions.SuspiciousOperation):
-            full_path = finders.find(norm_source_path)
+            full_path = finders.find(norm_source_path, all=False)
 
         if full_path is None:
             raise ValueError(f"Can't find staticfile named: {source_path}")

src/static_precompiler/compilers/libsass.py

@@ -45,12 +45,15 @@ def compile_file(self, source_path: str) -> str:
 
         try:
             if self.is_sourcemap_enabled:
-                compiled, sourcemap = sass.compile(
+                result = sass.compile(
                     filename=full_source_path,
                     source_map_filename=sourcemap_path,
                     output_filename_hint=full_output_path,
                     include_paths=self.load_paths,
                 )
+                if result is None:
+                    raise exceptions.StaticCompilationError(f"Could not compile {source_path}")
+                compiled, sourcemap = result
             else:
                 compile_kwargs: Dict[str, Any] = {}
                 if self.load_paths:
@@ -78,7 +81,7 @@ def compile_file(self, source_path: str) -> str:
 
     def compile_source(self, source: str) -> str:
         try:
-            compiled: str = sass.compile(string=source, indented=self.indented, include_paths=self.load_paths)
+            compiled = sass.compile(string=source, indented=self.indented, include_paths=self.load_paths)
         except sass.CompileError as e:
             raise exceptions.StaticCompilationError("Could not compile source") from e
 

src/static_precompiler/utils.py

@@ -2,7 +2,7 @@
 import os
 import posixpath
 import subprocess
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
 
 from django.utils import encoding
 
@@ -38,12 +38,11 @@ def normalize_whitespace(text: str) -> str:
 
 
 # noinspection PyShadowingBuiltins
-def run_command(
-    args: List[str], input: Optional[Union[bytes, str]] = None, cwd: Optional[str] = None
-) -> Tuple[int, str, str]:
+def run_command(args: List[str], input: Optional[str] = None, cwd: Optional[str] = None) -> Tuple[int, str, str]:
     popen_kwargs: Dict[str, Any] = {
         "stdout": subprocess.PIPE,
         "stderr": subprocess.PIPE,
+        "universal_newlines": True,
     }
 
     if cwd is not None:
@@ -57,14 +56,11 @@ def run_command(
 
     p = subprocess.Popen(args, **popen_kwargs)
 
-    if input:
-        input = encoding.smart_bytes(input)
-
     output, error = p.communicate(input)
     return_code = p.poll()
     assert return_code is not None
 
-    return return_code, encoding.smart_str(output), encoding.smart_str(error)
+    return return_code, output, error
 
 
 def compile_static(path: str) -> str:

tests/test_base_compiler.py

@@ -195,9 +195,6 @@ def test_compile_lazy(monkeypatch):
     # noinspection PyUnresolvedReferences
     assert compiler.compile.calls == [pretend.call("dummy.coffee")]
 
-    assert compiler.compile(encoding.force_str("foo")).startswith(encoding.force_str("")) is True
-    assert compiler.compile(encoding.force_bytes("foo")).startswith(encoding.force_bytes("")) is True
-
 
 def test_find_dependencies():
     compiler = compilers.BaseCompiler()

tests/test_scss.py

@@ -293,7 +293,9 @@ def test_precision(precision, monkeypatch, tmpdir):
 
     with open(full_output_path) as compiled:
         compiled_css = compiled.read()
-        line_height = re.search(r"line-height: (.+?);", compiled_css).groups()[0]
+        match = re.search(r"line-height: (.+?);", compiled_css)
+        assert match
+        line_height = match.groups()[0]
         assert len(line_height.split(".")[-1]) == expected_precision