Guard all PyThaiNLP write operations with is_read_only_mode()

Co-authored-by: bact <128572+bact@users.noreply.github.com>

Author: Copilot

pythainlp/classify/param_free.py

@@ -96,6 +96,12 @@ def predict(self, x1: str, k: int = 1) -> str:
 
     def save(self, path: str) -> None:
         """:param str path: path to save model"""
+        from pythainlp.tools.path import is_read_only_mode
+
+        if is_read_only_mode():
+            raise PermissionError(
+                "PyThaiNLP is in read-only mode. Cannot save model."
+            )
         with open(path, "w", encoding="utf-8") as f:
             json.dump(
                 {

pythainlp/cli/benchmark.py

@@ -157,6 +157,15 @@ def __init__(self, name: str, argv: Sequence[str]) -> None:
             dir_name = os.path.dirname(args.input_file)
             file_name = args.input_file.split("/")[-1].split(".")[0]
 
+            from pythainlp.tools.path import is_read_only_mode
+
+            if is_read_only_mode():
+                safe_print(
+                    "PyThaiNLP is in read-only mode. "
+                    "Benchmark details cannot be saved."
+                )
+                return
+
             res_path = "%s/eval-%s.yml" % (dir_name, file_name)
             safe_print("Evaluation result is saved to %s" % res_path)
 

pythainlp/cli/misspell.py

@@ -70,5 +70,14 @@ def __init__(self, argv: Sequence[str]) -> None:
             base, ext = os.path.splitext(args.file)
             args.output = f"{base}-misspelled-r{args.misspell_ratio}-seed{args.seed}{ext}"
 
+        from pythainlp.tools.path import is_read_only_mode
+
+        if is_read_only_mode():
+            print(
+                "PyThaiNLP is in read-only mode. "
+                f"Cannot write output to {args.output!r}."
+            )
+            return
+
         with open(args.output, "w", encoding="utf-8") as f:
             f.writelines(misspelled_lines)

pythainlp/tag/_tag_perceptron.py

@@ -202,6 +202,12 @@ def train(
 
         # save the model
         if save_loc is not None:
+            from pythainlp.tools.path import is_read_only_mode
+
+            if is_read_only_mode():
+                raise PermissionError(
+                    "PyThaiNLP is in read-only mode. Cannot save model."
+                )
             data: dict[str, Union[dict, list]] = {}
             data["weights"] = self.model.weights
             data["tagdict"] = self.tagdict

pythainlp/tools/path.py

@@ -202,7 +202,8 @@ def get_pythainlp_data_path() -> str:
 
     resolved = data_dir or os.path.join("~", PYTHAINLP_DEFAULT_DATA_DIR)
     path = os.path.expanduser(resolved)
-    os.makedirs(path, exist_ok=True)
+    if not is_read_only_mode():
+        os.makedirs(path, exist_ok=True)
     return path
 
 

pythainlp/translate/tokenization_small100.py

@@ -375,6 +375,12 @@ def __setstate__(self, d: dict) -> None:
     def save_vocabulary(
         self, save_directory: str, filename_prefix: Optional[str] = None
     ) -> tuple[str, str]:
+        from pythainlp.tools.path import is_read_only_mode
+
+        if is_read_only_mode():
+            raise PermissionError(
+                "PyThaiNLP is in read-only mode. Cannot save vocabulary."
+            )
         save_dir = Path(save_directory)
         if not save_dir.is_dir():
             raise OSError(f"{save_directory} should be a directory")
@@ -468,5 +474,11 @@ def load_json(path: str) -> Union[dict[str, str], list[str]]:
 def save_json(
     data: Union[Mapping[str, Union[str, int]], list[str]], path: str
 ) -> None:
+    from pythainlp.tools.path import is_read_only_mode
+
+    if is_read_only_mode():
+        raise PermissionError(
+            "PyThaiNLP is in read-only mode. Cannot save file."
+        )
     with open(path, "w") as f:
         json.dump(data, f, indent=2)

tests/core/test_tools.py

@@ -248,3 +248,58 @@ def test_is_read_only_mode_conflict(self):
                 is_read_only_mode()
             self.assertIn("PYTHAINLP_READ_ONLY", str(ctx.exception))
             self.assertIn("PYTHAINLP_READ_MODE", str(ctx.exception))
+
+    def test_get_pythainlp_data_path_no_makedirs_in_read_only(self):
+        """Test that get_pythainlp_data_path skips makedirs in read-only mode."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            new_dir = os.path.join(tmpdir, "new-pythainlp-data")
+            with patch.dict(
+                os.environ,
+                {"PYTHAINLP_DATA": new_dir, "PYTHAINLP_READ_ONLY": "1"},
+                clear=False,
+            ):
+                os.environ.pop("PYTHAINLP_DATA_DIR", None)
+                os.environ.pop("PYTHAINLP_READ_MODE", None)
+                path = get_pythainlp_data_path()
+                self.assertEqual(path, new_dir)
+                # Directory must NOT be created in read-only mode
+                self.assertFalse(
+                    os.path.exists(new_dir),
+                    "Data directory should not be created in read-only mode",
+                )
+
+    def test_param_free_save_blocked_in_read_only(self):
+        """Test that GzipModel.save raises PermissionError in read-only mode."""
+        from pythainlp.classify.param_free import GzipModel
+
+        # Bypass __init__ (which needs numpy) — only the guard is under test
+        model = object.__new__(GzipModel)
+        with patch.dict(
+            os.environ,
+            {"PYTHAINLP_READ_ONLY": "1"},
+            clear=False,
+        ):
+            os.environ.pop("PYTHAINLP_READ_MODE", None)
+            with tempfile.TemporaryDirectory() as tmpdir:
+                with self.assertRaises(PermissionError):
+                    model.save(os.path.join(tmpdir, "model.json"))
+
+    def test_perceptron_train_save_blocked_in_read_only(self):
+        """Test that PerceptronTagger.train raises PermissionError when saving in read-only mode."""
+        from pythainlp.tag._tag_perceptron import PerceptronTagger
+
+        tagger = PerceptronTagger()
+        sentences = [[("กิน", "VV"), ("ข้าว", "NN")]]
+        with patch.dict(
+            os.environ,
+            {"PYTHAINLP_READ_ONLY": "1"},
+            clear=False,
+        ):
+            os.environ.pop("PYTHAINLP_READ_MODE", None)
+            with tempfile.TemporaryDirectory() as tmpdir:
+                with self.assertRaises(PermissionError):
+                    tagger.train(
+                        sentences,
+                        save_loc=os.path.join(tmpdir, "tagger.json"),
+                        nr_iter=1,
+                    )