spaceforge 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

spaceforge/__init__.py

@@ -4,10 +4,18 @@ Spaceforge - Spacelift Plugin Framework
 A Python framework for building Spacelift plugins with hook-based functionality.
 """
 
-from ._version import get_version
-from .cls import Binary, Context, MountedFile, Parameter, Policy, Variable, Webhook
-from .plugin import SpaceforgePlugin
-from .runner import PluginRunner
+from spaceforge._version import get_version
+from spaceforge.cls import (
+    Binary,
+    Context,
+    MountedFile,
+    Parameter,
+    Policy,
+    Variable,
+    Webhook,
+)
+from spaceforge.plugin import SpaceforgePlugin
+from spaceforge.runner import PluginRunner
 
 __version__ = get_version()
 __all__ = [

spaceforge/__main__.py

@@ -4,9 +4,9 @@ Main entry point for spaceforge module.
 
 import click
 
-from ._version import get_version
-from .generator import generate_command
-from .runner import runner_command
+from spaceforge._version import get_version
+from spaceforge.generator import generate_command
+from spaceforge.runner import runner_command
 
 
 @click.group()

spaceforge/_version.py

@@ -3,7 +3,6 @@ Dynamic version detection from git tags.
 """
 
 import subprocess
-import sys
 from typing import Optional
 
 

spaceforge/_version_scm.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
 
 __commit_id__ = commit_id = None

spaceforge/cls.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
@@ -19,8 +20,7 @@ class Binary:
 
     Attributes:
         name (str): The name of the binary file.
-        path (str): The path to the binary file.
-        sensitive (bool): Whether the binary file is sensitive.
+        download_urls (Dict[BinaryType, str]): A dictionary mapping binary types to their download URLs.
     """
 
     name: str
@@ -38,6 +38,7 @@ class Parameter:
         sensitive (bool): Whether the parameter contains sensitive information.
         required (bool): Whether the parameter is required.
         default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)
+        id (str): Unique identifier for the parameter.
     """
 
     name: str
@@ -45,6 +46,7 @@ class Parameter:
     sensitive: bool = False
     required: bool = False
     default: Optional[str] = None
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
 
     def __post_init__(self) -> None:
         if not self.required and self.default is None:
@@ -171,19 +173,21 @@ class PluginManifest:
     A class to represent the manifest of a Spacelift plugin.
 
     Attributes:
-        name_prefix (str): The name of the plugin, will be appended with a unique ID.
+        name (str): The name of the plugin, will be appended with a unique ID.
         description (str): A description of the plugin.
         author (str): The author of the plugin.
+        labels (list[str]): List of labels for the plugin.
         parameters (list[Parameter]): List of parameters for the plugin.
         contexts (list[Context]): List of contexts for the plugin.
         webhooks (list[Webhook]): List of webhooks for the plugin.
         policies (list[Policy]): List of policies for the plugin.
     """
 
-    name_prefix: str
+    name: str
     version: str
     description: str
     author: str
+    labels: Optional[List[str]] = optional_field
     parameters: Optional[List[Parameter]] = optional_field
     contexts: Optional[List[Context]] = optional_field
     webhooks: Optional[List[Webhook]] = optional_field

spaceforge/conftest.py

@@ -0,0 +1,89 @@
+"""Shared test fixtures for spaceforge tests."""
+
+import os
+import tempfile
+from typing import Dict, Generator, List
+from unittest.mock import Mock
+
+import pytest
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+@pytest.fixture
+def temp_dir() -> Generator[str, None, None]:
+    """Provide a temporary directory for test files."""
+    temp_dir = tempfile.mkdtemp()
+    yield temp_dir
+    import shutil
+
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+@pytest.fixture
+def test_plugin_content() -> str:
+    """Basic test plugin content."""
+    return """
+from spaceforge import SpaceforgePlugin, Parameter
+
+class TestPlugin(SpaceforgePlugin):
+    __plugin_name__ = "test"
+    __version__ = "1.0.0"
+    __author__ = "Test Author"
+    
+    __parameters__ = [
+        Parameter(
+            name="test_param",
+            description="Test parameter",
+            required=False,
+            default="default_value"
+        )
+    ]
+    
+    def after_plan(self) -> None:
+        pass
+"""
+
+
+@pytest.fixture
+def test_plugin_file(temp_dir: str, test_plugin_content: str) -> str:
+    """Create a test plugin file."""
+    plugin_path = os.path.join(temp_dir, "plugin.py")
+    with open(plugin_path, "w") as f:
+        f.write(test_plugin_content)
+    return plugin_path
+
+
+@pytest.fixture
+def mock_env() -> Dict[str, str]:
+    """Common test environment variables."""
+    return {
+        "SPACELIFT_API_TOKEN": "test_token",
+        "TF_VAR_spacelift_graphql_endpoint": "https://test.spacelift.io",
+    }
+
+
+@pytest.fixture
+def mock_api_response() -> Mock:
+    """Mock API response for testing."""
+    mock_response = Mock()
+    mock_response.read.return_value = b'{"data": {"test": "result"}}'
+    return mock_response
+
+
+class ExampleTestPlugin(SpaceforgePlugin):
+    """Reusable test plugin class."""
+
+    __plugin_name__ = "example"
+    __version__ = "1.0.0"
+    __author__ = "Test"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.hook_calls: List[str] = []
+
+    def after_plan(self) -> None:
+        self.hook_calls.append("after_plan")
+
+    def before_apply(self) -> None:
+        self.hook_calls.append("before_apply")

spaceforge/generator.py

@@ -4,7 +4,7 @@ YAML generator for Spacelift plugins.
 
 import importlib.util
 import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 import yaml
 
@@ -46,6 +46,7 @@ class PluginGenerator:
         self.plugin_class: Optional[Type[SpaceforgePlugin]] = None
         self.plugin_instance: Optional[SpaceforgePlugin] = None
         self.plugin_working_directory: Optional[str] = None
+        self.config: Optional[Dict[str, Any]] = None
 
     def load_plugin(self) -> None:
         """Load the plugin class from the specified path."""
@@ -80,8 +81,15 @@ class PluginGenerator:
         self.plugin_working_directory = (
             "/mnt/workspace/plugins/" + plugin_class.__plugin_name__.lower()
         )
+        self.config = {
+            "setup_virtual_env": (
+                f"cd {self.plugin_working_directory} && python -m venv ./venv && "
+                + "source venv/bin/activate && pip install spaceforge"
+            ),
+            "plugin_mounted_path": f"{self.plugin_working_directory}/{os.path.basename(self.plugin_path)}",
+        }
 
-    def get_plugin_metadata(self) -> Dict[str, str]:
+    def get_plugin_metadata(self) -> Dict[str, Union[str, List[str]]]:
         """Extract metadata from the plugin class."""
         if self.plugin_class is None:
             raise ValueError("Plugin class not loaded. Call load_plugin() first.")
@@ -97,6 +105,7 @@ class PluginGenerator:
                 self.plugin_class.__name__.lower().replace("plugin", ""),
             ),
             "version": getattr(self.plugin_class, "__version__", "1.0.0"),
+            "labels": getattr(self.plugin_class, "__labels__", []),
             "description": doc
             or f"A Spacelift plugin built with {self.plugin_class.__name__}",
             "author": getattr(self.plugin_class, "__author__", "Unknown"),
@@ -128,22 +137,14 @@ class PluginGenerator:
 
         return hook_methods
 
-    def get_plugin_contexts(self) -> List[Context]:
-        """Get context definitions from the plugin class."""
-
-        change_to_working_directory = f"cd {self.plugin_working_directory}"
-        hooks = {
-            "before_init": [
-                f"mkdir -p {self.plugin_working_directory}",
-            ],
-        }
-        mounted_files = []
-
-        # Add a virtual environment before_init hook if requirements.txt exists
-        if os.path.exists("requirements.txt"):
-            hooks["before_init"].append(
-                f"{change_to_working_directory} && python -m venv ./venv && source venv/bin/activate && pip install -r requirements.txt"
-            )
+    def _update_with_requirements(
+        self, hooks: Dict[str, List[str]], mounted_files: List[MountedFile]
+    ) -> None:
+        """Update the plugin hooks if there is a requirements.txt"""
+        if os.path.exists("requirements.txt") and self.config is not None:
+            if self.config["setup_virtual_env"] not in hooks["before_init"]:
+                hooks["before_init"].append(self.config["setup_virtual_env"])
+            hooks["before_init"].append(f"pip install -r requirements.txt")
             # read the requirements.txt file
             with open("requirements.txt", "r") as f:
                 mounted_files.append(
@@ -154,34 +155,77 @@ class PluginGenerator:
                     )
                 )
 
-        # Ensure the plugin file itself is mounted
-        plugin_mounted_path = (
-            f"{self.plugin_working_directory}/{os.path.basename(self.plugin_path)}"
-        )
-        if os.path.exists(self.plugin_path):
+    def _update_with_python_file(self, mounted_files: List[MountedFile]) -> None:
+        """Ensure the plugin file itself is mounted."""
+        if os.path.exists(self.plugin_path) and self.config is not None:
             with open(self.plugin_path, "r") as f:
                 mounted_files.append(
                     MountedFile(
-                        path=plugin_mounted_path,
+                        path=self.config["plugin_mounted_path"],
                         content=f.read(),
                         sensitive=False,
                     )
                 )
 
-        binary_cmd = self.generate_binary_install_command()
-        if binary_cmd != "":
-            hooks["before_init"].append(binary_cmd)
-
+    def _add_spaceforge_hooks(self, hooks: Dict[str, List[str]]) -> None:
         # Add the spaceforge hook to actually run the plugin
+        if self.config is None:
+            raise ValueError("Plugin config not set. Call load_plugin() first.")
+
         available_hooks = self.get_available_hooks()
         for hook in available_hooks:
             # Ensure the hook exists in the first context
             if hook not in hooks:
                 hooks[hook] = []
+
+            if self.config["setup_virtual_env"] not in hooks[hook]:
+                hooks[hook].append(self.config["setup_virtual_env"])
+
             hooks[hook].append(
-                f"{change_to_working_directory} && python -m spaceforge runner --plugin-file {plugin_mounted_path} {hook}"
+                f"cd /mnt/workspace/source/$TF_VAR_spacelift_project_root && python -m spaceforge runner --plugin-file {self.config['plugin_mounted_path']} {hook}"
             )
 
+    def _map_variables_to_parameters(self, contexts: List[Context]) -> None:
+        for context in contexts:
+            # Get the variables from the plugin and change the value_from_parameter to the ID of the parameter
+            # based on its name.
+            if context.env is None:
+                continue
+
+            for variable in context.env:
+                if variable.value_from_parameter:
+                    parameter_name = variable.value_from_parameter
+                    parameters = self.get_plugin_parameters()
+                    if parameters:
+                        parameter = next(
+                            (
+                                p
+                                for p in parameters
+                                if p.name == parameter_name or p.id == parameter_name
+                            ),
+                            None,
+                        )
+                        if parameter:
+                            variable.value_from_parameter = parameter.id
+                        else:
+                            raise ValueError(
+                                f"Parameter {parameter_name} not found for variable {variable.key}"
+                            )
+
+    def get_plugin_contexts(self) -> List[Context]:
+        """Get context definitions from the plugin class."""
+
+        f"cd {self.plugin_working_directory}"
+        hooks: Dict[str, List[str]] = {
+            "before_init": [f"mkdir -p {self.plugin_working_directory}"]
+        }
+        mounted_files: List[MountedFile] = []
+
+        self._update_with_requirements(hooks, mounted_files)
+        self._update_with_python_file(mounted_files)
+        self._generate_binary_install_command(hooks)
+        self._add_spaceforge_hooks(hooks)
+
         # Get the contexts and append the hooks and mounted files to it.
         if self.plugin_class is None:
             raise ValueError("Plugin class not loaded. Call load_plugin() first.")
@@ -208,12 +252,14 @@ class PluginGenerator:
         contexts[0].hooks.update(hooks)
         contexts[0].mounted_files.extend(mounted_files)
 
+        self._map_variables_to_parameters(contexts)
+
         return contexts
 
-    def generate_binary_install_command(self) -> str:
+    def _generate_binary_install_command(self, hooks: Dict[str, List[str]]) -> None:
         binaries = self.get_plugin_binaries()
         if binaries is None:
-            return ""
+            return None
 
         binary_cmd = ""
         if len(binaries) > 0:
@@ -238,12 +284,17 @@ class PluginGenerator:
                 else "echo 'arm64 binary not available' && exit 1"
             )
 
-            binary_cmd += '([[ "$(echo "$(arch)")" == "x86_64" ]] && {} || {})'.format(
-                amd64_download_command, arm64_download_command
+            binary_cmd += (
+                '([[ "$(echo "$(arch)")" == "x86_64" ]] && {} || {}) && '.format(
+                    amd64_download_command, arm64_download_command
+                )
             )
-            if i < len(binaries) - 1:
-                binary_cmd += " && "
-        return binary_cmd
+
+        if binary_cmd != "":
+            binary_cmd += "cd /mnt/workspace/source/$TF_VAR_spacelift_project_root"
+
+        hooks["before_init"].append(binary_cmd)
+        return None
 
     def get_plugin_binaries(self) -> Optional[List[Binary]]:
         """Get binary definitions from the plugin class."""
@@ -265,10 +316,11 @@ class PluginGenerator:
         metadata = self.get_plugin_metadata()
 
         return PluginManifest(
-            name_prefix=metadata.get("name_prefix", "unknown"),
-            version=metadata.get("version", "1.0.0"),
-            description=metadata.get("description", ""),
-            author=metadata.get("author", "Unknown"),
+            name=str(metadata.get("name_prefix", "unknown")),
+            version=str(metadata.get("version", "1.0.0")),
+            description=str(metadata.get("description", "")),
+            author=str(metadata.get("author", "Unknown")),
+            labels=list(metadata.get("labels", [])),
             parameters=self.get_plugin_parameters(),
             contexts=self.get_plugin_contexts(),
             webhooks=self.get_plugin_webhooks(),

spaceforge/plugin.py

@@ -9,7 +9,7 @@ import os
 import subprocess
 import urllib.request
 from abc import ABC
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
 
 
 class SpaceforgePlugin(ABC):
@@ -31,14 +31,17 @@ class SpaceforgePlugin(ABC):
     __author__ = "Spacelift Team"
 
     def __init__(self) -> None:
+        self._run_id = os.environ.get("TF_VAR_spacelift_run_id", "local")
+        self._is_local = self._run_id == "local"
         self.logger = self._setup_logger()
 
-        self._api_token = os.environ.get("SPACELIFT_API_TOKEN", False)
-        self._spacelift_domain = os.environ.get(
-            "TF_VAR_spacelift_graphql_endpoint", False
+        self._api_token = os.environ.get("SPACELIFT_API_TOKEN") or False
+        self._spacelift_domain = (
+            os.environ.get("TF_VAR_spacelift_graphql_endpoint") or False
         )
-        self._api_enabled = self._api_token != False and self._spacelift_domain != False
-        self._workspace_root = os.environ.get("WORKSPACE_ROOT", os.getcwd())
+        self._api_enabled = bool(self._api_token and self._spacelift_domain)
+        self._workspace_root = os.getcwd()
+        self._spacelift_markdown_endpoint = None
 
         # This should be the last thing we do in the constructor
         # because we set api_enabled to false if the domain is set up incorrectly.
@@ -54,6 +57,11 @@ class SpaceforgePlugin(ABC):
                 )
                 self._api_enabled = False
 
+            if self._api_enabled:
+                self._spacelift_markdown_endpoint = self._spacelift_domain.replace(
+                    "/graphql", "/worker/plugin_logs_url"
+                )
+
     def _setup_logger(self) -> logging.Logger:
         """Set up logging for the plugin."""
 
@@ -62,7 +70,7 @@ class SpaceforgePlugin(ABC):
         warn_color = "\033[33m"
         error_color = "\033[31m"
         end_color = "\033[0m"
-        run_id = os.environ.get("TF_VAR_spacelift_run_id", "local")
+        run_id = self._run_id
         plugin_name = self.__plugin_name__
 
         class ColorFormatter(logging.Formatter):
@@ -93,7 +101,7 @@ class SpaceforgePlugin(ABC):
             handler.setFormatter(ColorFormatter())
 
         # Always check for debug mode spacelift variable
-        if os.environ.get("SPACELIFT_DEBUG"):
+        if os.environ.get("SPACELIFT_DEBUG") or self._is_local:
             logger.setLevel(logging.DEBUG)
         else:
             logger.setLevel(logging.INFO)
@@ -175,7 +183,7 @@ class SpaceforgePlugin(ABC):
     ) -> Dict[str, Any]:
         if not self._api_enabled:
             self.logger.error(
-                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "SPACELIFT_DOMAIN".'
+                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "TF_VAR_spacelift_graphql_endpoint".'
             )
             exit(1)
 
@@ -192,7 +200,7 @@ class SpaceforgePlugin(ABC):
             data["variables"] = variables
 
         req = urllib.request.Request(
-            f"{self._spacelift_domain}/graphql",
+            self._spacelift_domain,  # type: ignore[arg-type]
             json.dumps(data).encode("utf-8"),
             headers,
         )
@@ -226,8 +234,93 @@ class SpaceforgePlugin(ABC):
             return data
 
     def send_markdown(self, markdown: str) -> None:
-        # TODO
-        print(markdown)
+        """
+        Send a markdown message to the Spacelift run.
+
+        Args:
+            markdown: The markdown content to send
+        """
+        if self._is_local:
+            self.logger.info(
+                "Spacelift run is local. Not uploading markdown. Below is a preview of what would be sent"
+            )
+            self.logger.info(markdown)
+            return
+
+        if self._spacelift_markdown_endpoint is None:
+            self.logger.error(
+                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "TF_VAR_spacelift_graphql_endpoint".'
+            )
+            exit(1)
+
+        headers = {"Authorization": f"Bearer {self._api_token}"}
+        body = {
+            "plugin_name": self.__plugin_name__,
+        }
+
+        # First we get the signed url for uploading
+        req = urllib.request.Request(
+            self._spacelift_markdown_endpoint,
+            json.dumps(body).encode("utf-8"),
+            headers,
+        )
+
+        with urllib.request.urlopen(req) as response:
+            if response.status != 200:
+                self.logger.error(
+                    f"Error getting signed URL for markdown upload: {response.status}"
+                )
+                return
+
+            raw_response = response.read().decode("utf-8")
+            self.logger.debug(raw_response)
+            resp: Dict[str, Any] = json.loads(raw_response)
+            if "url" not in resp or "headers" not in resp:
+                self.logger.error(
+                    "Markdown signed url response does not contain 'url' or 'headers' key."
+                )
+                return
+
+            signed_url = resp["url"]
+            headers = resp["headers"]
+            headers["Content-Type"] = "text/markdown"
+            headers["Content-Length"] = str(len(markdown))
+
+        # Now we upload the markdown content to the signed URL
+        req = urllib.request.Request(
+            signed_url,
+            data=markdown.encode("utf-8"),
+            headers=headers,
+            method="PUT",
+        )
+
+        with urllib.request.urlopen(req) as put_response:
+            if put_response.status != 200:
+                self.logger.error(
+                    f"Error uploading markdown content: {put_response.status}"
+                )
+                return
+            self.logger.debug("Markdown content uploaded successfully.")
+
+    def add_to_policy_input(self, input_name: str, data: Dict[str, Any]) -> None:
+        """
+        Add data to the policy input for the current Spacelift run.
+
+        Args:
+            input_name: The name of the input to add (will be available as input.third_party_metadata.custom.{input_name} to the policy).
+            data: Dictionary containing data to add to the policy input
+        """
+        if self._is_local:
+            self.logger.info(
+                "Spacelift run is local. Not writing custom policy input. Below is a preview of what would be written"
+            )
+            self.logger.info(json.dumps(data, indent=2))
+            return
+
+        with open(
+            f"{self._workspace_root}/{input_name}.custom.spacelift.json", "w"
+        ) as f:
+            f.write(json.dumps(data))
 
     # Hook methods - override these in your plugin
     def before_init(self) -> None:

spaceforge/runner.py

@@ -4,7 +4,6 @@ Plugin runner for executing hook methods.
 
 import importlib.util
 import os
-import sys
 from typing import Optional
 
 
@@ -102,14 +101,3 @@ def runner_command(hook_name: str, plugin_file: str) -> None:
     """
     runner = PluginRunner(plugin_file)
     runner.run_hook(hook_name)
-
-
-def main() -> None:
-    """Legacy main entry point for backward compatibility."""
-    if len(sys.argv) != 2:
-        print("Usage: python -m spaceforge.runner <hook_name>")
-        sys.exit(1)
-
-    hook_name = sys.argv[1]
-    runner = PluginRunner()
-    runner.run_hook(hook_name)

spaceforge/schema.json

@@ -118,7 +118,7 @@
       "type": "object"
     },
     "Parameter": {
-      "description": "A class to represent a parameter with a name and value.\n\nAttributes:\n    name (str): The name of the parameter.\n    description (str): A description of the parameter.\n    sensitive (bool): Whether the parameter contains sensitive information.\n    required (bool): Whether the parameter is required.\n    default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)",
+      "description": "A class to represent a parameter with a name and value.\n\nAttributes:\n    name (str): The name of the parameter.\n    description (str): A description of the parameter.\n    sensitive (bool): Whether the parameter contains sensitive information.\n    required (bool): Whether the parameter is required.\n    default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)\n    id (str): Unique identifier for the parameter.",
       "properties": {
         "name": {
           "title": "Name",
@@ -149,6 +149,10 @@
           ],
           "default": null,
           "title": "Default"
+        },
+        "id": {
+          "title": "Id",
+          "type": "string"
         }
       },
       "required": [
@@ -285,10 +289,10 @@
       "type": "object"
     }
   },
-  "description": "A class to represent the manifest of a Spacelift plugin.\n\nAttributes:\n    name_prefix (str): The name of the plugin, will be appended with a unique ID.\n    description (str): A description of the plugin.\n    author (str): The author of the plugin.\n    parameters (list[Parameter]): List of parameters for the plugin.\n    contexts (list[Context]): List of contexts for the plugin.\n    webhooks (list[Webhook]): List of webhooks for the plugin.\n    policies (list[Policy]): List of policies for the plugin.",
+  "description": "A class to represent the manifest of a Spacelift plugin.\n\nAttributes:\n    name (str): The name of the plugin, will be appended with a unique ID.\n    description (str): A description of the plugin.\n    author (str): The author of the plugin.\n    labels (list[str]): List of labels for the plugin.\n    parameters (list[Parameter]): List of parameters for the plugin.\n    contexts (list[Context]): List of contexts for the plugin.\n    webhooks (list[Webhook]): List of webhooks for the plugin.\n    policies (list[Policy]): List of policies for the plugin.",
   "properties": {
-    "name_prefix": {
-      "title": "Name Prefix",
+    "name": {
+      "title": "Name",
       "type": "string"
     },
     "version": {
@@ -303,6 +307,20 @@
       "title": "Author",
       "type": "string"
     },
+    "labels": {
+      "anyOf": [
+        {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "title": "Labels"
+    },
     "parameters": {
       "anyOf": [
         {
@@ -361,7 +379,7 @@
     }
   },
   "required": [
-    "name_prefix",
+    "name",
     "version",
     "description",
     "author"