ZedScripts 0.0.2__tar.gz

zedscripts-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PZ Wiki Modding
+
+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.

zedscripts-0.0.2/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: ZedScripts
+Version: 0.0.2
+Author: SimKDT
+License-Expression: MIT
+Requires-Python: >=3.12.3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lsprotocol
+Requires-Dist: pygls
+Requires-Dist: requests-cache
+Requires-Dist: pydantic
+Requires-Dist: deepmerge
+Provides-Extra: build
+Requires-Dist: pyinstaller; extra == "build"
+Provides-Extra: debug
+Requires-Dist: debugpy; extra == "debug"
+Dynamic: license-file
+
+# ZedScripts LSP
+
+![ZedScripts-LSP](https://img.shields.io/badge/Latest_version-0.0.2-blue)
+[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts-LSP?label=License)](LICENSE)
+![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts-LSP?label=Code%20Size)
+[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+
+> [!IMPORTANT]
+> Work In Progress, this is a BETA release
+
+ZedScripts LSP is a language server protocol implementation in Python for the [scripting format]() of Project Zomboid. Previously a VSCode extension, it is now reimplemented as a standalone LSP.
+
+## Installation
+### Releases
+
+### Python package
+
+<!-- <details open>
+<summary>PyPi</summary>
+
+```bash
+pip install ZedScripts-LSP
+```
+</details> -->
+
+<details>
+<summary>Git</summary>
+
+```bash
+pip install git+https://github.com/PZ-Wiki-Modding/ZedScripts-LSP.git
+```
+</details>
+
+<details>
+<summary>Local</summary>
+
+```bash
+pip install .
+```
+</details>
+
+## Usage
+
+You can either launch the LSP from Python or you can launch the software as is.
+
+### LSP cache directory
+
+The LSP uses a cache directory on your system to store temporary files and logs as well as configuration files. You can find it here: 
+
+<details>
+<summary>Linux</summary>
+
+```bash
+~/.zedscripts
+```
+</details>
+
+<details>
+<summary>Windows</summary>
+
+```bash
+%USERPROFILE%\.zedscripts
+```
+</details>
+
+### Configuration
+
+The LSP uses configurations files which provide information to the LSP about various settings. You have access to a global configuration file
+
+Example configuration:
+```json
+{
+    "dataset": {
+        "latest": true
+    },
+    "libraries": [
+        "/home/simon/.steam/debian-installation/steamapps/common/ProjectZomboid/projectzomboid/media",
+    ]
+}
+```
+
+WIP: proper documentation will come soon
+
+## License
+See [LICENSE](LICENSE) for details.

zedscripts-0.0.2/README.md

@@ -0,0 +1,86 @@
+# ZedScripts LSP
+
+![ZedScripts-LSP](https://img.shields.io/badge/Latest_version-0.0.2-blue)
+[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts-LSP?label=License)](LICENSE)
+![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts-LSP?label=Code%20Size)
+[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+
+> [!IMPORTANT]
+> Work In Progress, this is a BETA release
+
+ZedScripts LSP is a language server protocol implementation in Python for the [scripting format]() of Project Zomboid. Previously a VSCode extension, it is now reimplemented as a standalone LSP.
+
+## Installation
+### Releases
+
+### Python package
+
+<!-- <details open>
+<summary>PyPi</summary>
+
+```bash
+pip install ZedScripts-LSP
+```
+</details> -->
+
+<details>
+<summary>Git</summary>
+
+```bash
+pip install git+https://github.com/PZ-Wiki-Modding/ZedScripts-LSP.git
+```
+</details>
+
+<details>
+<summary>Local</summary>
+
+```bash
+pip install .
+```
+</details>
+
+## Usage
+
+You can either launch the LSP from Python or you can launch the software as is.
+
+### LSP cache directory
+
+The LSP uses a cache directory on your system to store temporary files and logs as well as configuration files. You can find it here: 
+
+<details>
+<summary>Linux</summary>
+
+```bash
+~/.zedscripts
+```
+</details>
+
+<details>
+<summary>Windows</summary>
+
+```bash
+%USERPROFILE%\.zedscripts
+```
+</details>
+
+### Configuration
+
+The LSP uses configurations files which provide information to the LSP about various settings. You have access to a global configuration file
+
+Example configuration:
+```json
+{
+    "dataset": {
+        "latest": true
+    },
+    "libraries": [
+        "/home/simon/.steam/debian-installation/steamapps/common/ProjectZomboid/projectzomboid/media",
+    ]
+}
+```
+
+WIP: proper documentation will come soon
+
+## License
+See [LICENSE](LICENSE) for details.

zedscripts-0.0.2/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "ZedScripts"
+description = ""
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.12.3"
+version = "0.0.2"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "SimKDT" },
+]
+dependencies = [
+    "lsprotocol",
+    "pygls",
+    "requests-cache",
+    "pydantic",
+    "deepmerge",
+]
+
+[project.optional-dependencies]
+build = [
+    "pyinstaller"
+]
+debug = [
+    "debugpy"
+]
+
+# used to load locale JSON files
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.package-data]
+ZedScripts = [
+    "locale/*.json"
+]

zedscripts-0.0.2/setup.cfg

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

zedscripts-0.0.2/src/ZedScripts/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

zedscripts-0.0.2/src/ZedScripts/__init__.py

@@ -0,0 +1,38 @@
+import os
+import logging
+from pathlib import Path
+
+IS_DEBUG = os.getenv("ZEDSCRIPTS_DEBUG_MODE") == "1"
+
+ZEDSCRIPT_CACHE_DIR = Path.home() / ".zedscripts"
+"""
+Cache directory to hold various information related to ZedScripts.
+"""
+ZEDSCRIPT_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# config files
+CONFIGURATION_FILE_NAME = ".zedscripts.json"
+GLOBAL_CONFIGURATION_FILE = (ZEDSCRIPT_CACHE_DIR / CONFIGURATION_FILE_NAME).resolve()
+
+# setup the logger
+log_file = ZEDSCRIPT_CACHE_DIR / "server.log"
+
+level = logging.DEBUG if IS_DEBUG else logging.INFO
+logging.basicConfig(
+    filename=log_file,
+    level=level,
+    format="%(asctime)s %(levelname)s %(message)s",
+    filemode="w",
+    # force=True,
+)
+
+logging.info("ZedScripts logger initialized. Debug mode: %s", IS_DEBUG)
+
+IDENTIFIER = "ZedScripts"
+SOURCE = IDENTIFIER
+
+SCRIPTS_DATA_MANIFEST = "https://raw.githubusercontent.com/PZ-Wiki-Modding/pz-scripts-data/refs/heads/main/manifest.json"
+SCRIPTS_BLOCKS_DATA_LINK = "https://raw.githubusercontent.com/PZ-Wiki-Modding/pz-scripts-data/refs/tags/{best_tag}/out/scriptsBlocks.json"
+ROOTS_DATA_LINK = "https://raw.githubusercontent.com/PZ-Wiki-Modding/pz-scripts-data/refs/tags/{best_tag}/out/roots.json"
+
+SCRIPTSDOCS_LINK = "https://pz-wiki-modding.github.io/PZ-API-Docs/scripts/"

zedscripts-0.0.2/src/ZedScripts/enums/Diagnostic.py

@@ -0,0 +1,165 @@
+import enum
+from typing import Any
+
+from lsprotocol.types import DiagnosticSeverity, DiagnosticTag
+
+from ..enums.SyntaxErrorType import SyntaxErrorType
+from ..providers.diagnostics import DiagnosticDefinition
+
+
+class DiagnosticType(enum.Enum):
+    @classmethod
+    def _missing_(cls, value: Any) -> 'DiagnosticType | None':
+        if isinstance(value, SyntaxErrorType):
+            return cls["PARSER_" + value.name]
+        return None
+
+    # syntax diagnostics
+    PARSER_TOO_MANY_CLOSING_BRACKETS =       enum.auto()
+    PARSER_BLOCK_MISSING_TYPE =              enum.auto()
+    PARSER_BLOCK_NOT_CLOSED =                enum.auto()
+    PARSER_UNPARSED_TOKENS =                 enum.auto()
+
+    # block diagnostics
+    BLOCK_UNKNOWN_BLOCK =                    enum.auto()
+
+    # ID related diagnostics
+    BLOCK_UNEXPECTED_ID =                    enum.auto()
+    BLOCK_MISSING_ID =                       enum.auto()
+    BLOCK_HAS_ID_IN_PARENT =                 enum.auto()
+    BLOCK_ID_CANNOT_CONTAIN_SPACES =         enum.auto()
+    BLOCK_INVALID_ID =                       enum.auto()
+    BLOCK_FORBIDDEN_ID =                     enum.auto()
+
+    # parameters diagnostics
+    VALUE_UNKNOWN_PARAMETER =                enum.auto()
+    VALUE_DEPRECATED_REPLACEMENT_VERSION =   enum.auto()
+    VALUE_DEPRECATED_REPLACEMENT =           enum.auto()
+    VALUE_DEPRECATED_VERSION =               enum.auto()
+    VALUE_DEPRECATED =                       enum.auto()
+    VALUE_DUPLICATE =                        enum.auto()
+    VALUE_MISSING =                          enum.auto()
+    VALUE_FORBIDDEN =                        enum.auto()
+    VALUE_INVALID_TYPE =                     enum.auto()
+    VALUE_INVALID_OBJECT_FORMAT =            enum.auto()
+    VALUE_INVALID_OBJECT_KEY_TYPE =          enum.auto()
+    VALUE_INVALID_OBJECT_VALUE_TYPE =        enum.auto()
+    VALUE_WRONGLY_FORMATTED_KEY_VALUE_PAIR = enum.auto()
+    VALUE_WITH_NEWLINE =                     enum.auto()
+    VALUE_INVALID_BLOCK_REFERENCE =          enum.auto()
+    VALUE_CANNOT_PROVIDE_MODULE =            enum.auto()
+    VALUE_BLOCK_REF_CANNOT_BE_EMPTY =        enum.auto()
+    VALUE_UNMATCHED_BLOCK_REF =              enum.auto()
+    VALUE_MULTIPLE_BLOCK_REFS =              enum.auto()
+
+
+# syntax diagnostics
+DiagnosticDefinition(DiagnosticType.PARSER_TOO_MANY_CLOSING_BRACKETS,
+                     DiagnosticSeverity.Error)
+DiagnosticDefinition(DiagnosticType.PARSER_BLOCK_MISSING_TYPE,
+                     DiagnosticSeverity.Error)
+DiagnosticDefinition(DiagnosticType.PARSER_BLOCK_NOT_CLOSED,
+                     DiagnosticSeverity.Warning)
+DiagnosticDefinition(DiagnosticType.PARSER_UNPARSED_TOKENS,
+                     DiagnosticSeverity.Error)
+
+# block diagnostics
+DiagnosticDefinition(DiagnosticType.BLOCK_UNKNOWN_BLOCK,
+                     DiagnosticSeverity.Error,
+                     args={"type": str},
+                     tags=[DiagnosticTag.Unnecessary])
+
+# ID related diagnostics
+DiagnosticDefinition(DiagnosticType.BLOCK_UNEXPECTED_ID,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "id": str},
+                     tags=[DiagnosticTag.Unnecessary])
+DiagnosticDefinition(DiagnosticType.BLOCK_MISSING_ID,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "id": str})
+DiagnosticDefinition(DiagnosticType.BLOCK_HAS_ID_IN_PARENT,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "parent_type": str, "invalid_blocks": list},
+                     tags=[DiagnosticTag.Unnecessary])
+DiagnosticDefinition(DiagnosticType.BLOCK_ID_CANNOT_CONTAIN_SPACES,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "id": str})
+DiagnosticDefinition(DiagnosticType.BLOCK_INVALID_ID,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "id": str, "validIDs": list})
+DiagnosticDefinition(DiagnosticType.BLOCK_FORBIDDEN_ID,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "id": str, "forbiddenIDs": list})
+
+# parameter diagnostics
+DiagnosticDefinition(DiagnosticType.VALUE_UNKNOWN_PARAMETER,
+                     DiagnosticSeverity.Hint,
+                     args={"type": str, "key": str},
+                     tags=[DiagnosticTag.Unnecessary])
+DiagnosticDefinition(DiagnosticType.VALUE_DEPRECATED_REPLACEMENT_VERSION,
+                     DiagnosticSeverity.Warning,
+                     args={"description": str, "replacement": str, "version": str},
+                     tags=[DiagnosticTag.Deprecated])
+DiagnosticDefinition(DiagnosticType.VALUE_DEPRECATED_REPLACEMENT,
+                     DiagnosticSeverity.Warning,
+                     args={"description": str, "replacement": str},
+                     tags=[DiagnosticTag.Deprecated])
+DiagnosticDefinition(DiagnosticType.VALUE_DEPRECATED_VERSION,
+                     DiagnosticSeverity.Warning,
+                     args={"description": str, "version": str},
+                     tags=[DiagnosticTag.Deprecated])
+DiagnosticDefinition(DiagnosticType.VALUE_DEPRECATED,
+                     DiagnosticSeverity.Warning,
+                     args={"description": str},
+                     tags=[DiagnosticTag.Deprecated])
+DiagnosticDefinition(DiagnosticType.VALUE_DUPLICATE,
+                     DiagnosticSeverity.Warning,
+                     args={"type": str, "key": str})
+DiagnosticDefinition(DiagnosticType.VALUE_MISSING,
+                     DiagnosticSeverity.Warning,
+                     args={"type": str, "key": str})
+DiagnosticDefinition(DiagnosticType.VALUE_FORBIDDEN,
+                     DiagnosticSeverity.Warning,
+                     args={"type": str, "key": str, "forbidden_values": list, "accepted_values": list})
+DiagnosticDefinition(DiagnosticType.VALUE_INVALID_TYPE,
+                     DiagnosticSeverity.Error,
+                     args={"key": str, "value": str, "expected_type": str, "actual_type": str})
+DiagnosticDefinition(DiagnosticType.VALUE_INVALID_OBJECT_FORMAT,
+                     DiagnosticSeverity.Error,
+                     args={"type": str, "key": str, "key_value_separator": str})
+DiagnosticDefinition(DiagnosticType.VALUE_INVALID_OBJECT_KEY_TYPE,
+                     DiagnosticSeverity.Error,
+                     args={"obj_key": str, "key": str, "expected_type": str, "actual_type": str})
+DiagnosticDefinition(DiagnosticType.VALUE_INVALID_OBJECT_VALUE_TYPE,
+                     DiagnosticSeverity.Error,
+                     args={"obj_value": str, "key": str, "expected_type": str, "actual_type": str})
+DiagnosticDefinition(DiagnosticType.VALUE_WRONGLY_FORMATTED_KEY_VALUE_PAIR,
+                     DiagnosticSeverity.Warning,
+                     args={"type": str, "key": str, "value": str})
+DiagnosticDefinition(DiagnosticType.VALUE_WITH_NEWLINE,
+                     DiagnosticSeverity.Information,
+                     args={"type": str, "key": str, "value": str})
+DiagnosticDefinition(DiagnosticType.VALUE_INVALID_BLOCK_REFERENCE,
+                     DiagnosticSeverity.Error,
+                     args={"value": str})
+DiagnosticDefinition(DiagnosticType.VALUE_CANNOT_PROVIDE_MODULE,
+                     DiagnosticSeverity.Error,
+                     args={"value": str, "module": str})
+DiagnosticDefinition(DiagnosticType.VALUE_BLOCK_REF_CANNOT_BE_EMPTY,
+                     DiagnosticSeverity.Error,
+                     args={"value": str})
+DiagnosticDefinition(DiagnosticType.VALUE_UNMATCHED_BLOCK_REF,
+                     DiagnosticSeverity.Error,
+                     args={"value": str, "parameter": str, "expected_block": str})
+DiagnosticDefinition(DiagnosticType.VALUE_MULTIPLE_BLOCK_REFS,
+                     DiagnosticSeverity.Error,
+                     args={"value": str, "parameter": str, "expected_block": str})
+
+
+# ensure that all diagnostic types have a corresponding definition
+for diagnostic_type in DiagnosticType:
+    assert diagnostic_type in DiagnosticDefinition.by_type, f"Missing definition for diagnostic type: {diagnostic_type}"
+
+
+
+

zedscripts-0.0.2/src/ZedScripts/enums/SyntaxErrorType.py

@@ -0,0 +1,7 @@
+import enum
+
+class SyntaxErrorType(enum.Enum):
+    TOO_MANY_CLOSING_BRACKETS = enum.auto()
+    BLOCK_MISSING_TYPE = enum.auto()
+    BLOCK_NOT_CLOSED = enum.auto()
+    UNPARSED_TOKENS = enum.auto()

zedscripts-0.0.2/src/ZedScripts/environment/__init__.py

@@ -0,0 +1,33 @@
+import enum
+
+
+class WorkspaceType(enum.StrEnum):
+    """Represents different types of workspace folders."""
+    LIBRARY = enum.auto()
+    """A library defined by the user to reference things from.
+    No validation should be performed on it."""
+    PROJECT = enum.auto()
+    """A workspace folder."""
+    SOLITARY = enum.auto()
+    """Files that are not opened as part of a workspace 
+    or library but should still be validated.
+    
+    This workspace always exists and just holds solitary files."""
+
+class VersionType(enum.StrEnum):
+    """Represents different version types the workspace folders follow."""
+    PRE_42 = enum.auto()
+    """Modded pre-42 folder structure."""
+    VERSIONING = enum.auto()
+    """Modded versioning folder.
+    
+    https://pzwiki.net/wiki/Mod_structure#Common_and_versioning_folders"""
+    COMMON = enum.auto()
+    """Modded folder `common`.
+    
+    https://pzwiki.net/wiki/Mod_structure#Common_and_versioning_folders"""
+    OTHER = enum.auto()
+    """Other uncategorized version."""
+    BASE_GAME = enum.auto()
+    """Base game files (e.g., `ProjectZomboid/media`)."""
+

zedscripts-0.0.2/src/ZedScripts/environment/config.py

@@ -0,0 +1,82 @@
+import logging
+import enum
+from pathlib import Path
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from ..scripts.version import DataVersion
+
+
+class DatasetTag(enum.Enum):
+    LATEST = "latest"
+    STABLE = "stable"
+
+
+
+class ReleaseModel(BaseModel):
+    major: int = Field(
+        description="Build game version number.",
+        ge=42,
+    )
+    minor: int = Field(
+        description="Minor game version number.",
+        ge=0,
+    )
+    patch: int = Field(
+        description="Patch game version number.",
+        ge=0,
+    )
+    version: Optional[int] = Field(
+        description="Dataset version number for the provided Build release (major.minor.patch). This is incremented whenever the dataset for a specific version is updated.",
+        default=None,
+        ge=0,
+    )
+
+class DatasetModel(BaseModel):
+    release: Optional[ReleaseModel] = Field(
+        description="Provides a configuration for the dataset version to use for validation. This overrides the `latest` and `stable` fields if set.",
+        default=None,
+    )
+    latest: Optional[bool] = Field(
+        description="Indicates whether to use the latest dataset version for validation. This is ignored if `release` is set. Overrides the `stable` field if set.",
+        default=False,
+    )
+    stable: Optional[bool] = Field(
+        description="Provides a configuration for the stable dataset version to use for validation. Ignored if `release` or `latest` is set.",
+        default=True,
+    )
+
+    def to_data_version(self) -> DataVersion | DatasetTag:
+        if self.release is None:
+            if self.latest:
+                return DatasetTag.LATEST
+            if self.stable:
+                return DatasetTag.STABLE
+            logging.warning("No dataset version specified, defaulting to 'stable'.")
+            return DatasetTag.STABLE
+        from ..scripts.dataset import Manifest
+        try:
+            return Manifest.from_release_model(self.release)
+        except Exception as e:
+            logging.error(f"Failed to get data version from release model: {e}. Defaulting to 'stable'.")
+            return DatasetTag.STABLE
+
+
+class ConfigurationModel(BaseModel):
+    """Represents the content of the configuration files for workspace environments."""
+    dataset: DatasetModel = Field(
+        description="Provides configuration for the dataset version to use for diagnostics.",
+        default_factory=DatasetModel,
+    )
+    libraries: set[Path] = Field(
+        description="Set of library folders to reference. Usually this should contain the base game folder.",
+        default_factory=set,
+    )
+    ignored: set[str] = Field(
+        description="Regex patterns for files and folders to ignore in the workspace.",
+        default=set([
+            r"tileGeometry\.txt",
+            r"tileDepthTextureAssignments\.txt",
+            r".+\.tiles\.txt"
+        ]),
+    )