ZedScripts 0.0.2__py3-none-any.whl

ZedScripts/__about__.py

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

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/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/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/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/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"
+        ]),
+    )