Move logger plugin to client monorepo

Author: pileks

.gitignore

@@ -82,7 +82,7 @@ profile_default/
 ipython_config.py
 
 # pyenv
-.python-version
+# .python-version
 
 # pipenv
 #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.

.python-version

@@ -0,0 +1 @@
+3.10

packages/plugins/polywrap-logger-plugin/.gitignore

@@ -0,0 +1,8 @@
+__pycache__
+.idea
+.vscode
+dist
+**/.pytest_cache/
+**/node_modules/
+**/.tox/
+wrap/

packages/plugins/polywrap-logger-plugin/README.md

@@ -0,0 +1,82 @@
+# Logger Python Plugin
+The Logger plugin implements the `logger-interface` from the `ens/wraps.eth:[email protected]` package (see [./src/schema.graphql](./src/schema.graphql)). By default, it logs all events using the Python `logging` module. You can customize this behavior by setting the `Logger` property on the plugin's configuration object (examples below).
+
+## Usage
+### 1. Configure Client
+When creating your Polywrap Python client, add the logger plugin:
+```python
+from polywrap_client_config_builder  import PolywrapClientConfigBuilder
+from polywrap_logger_plugin import logger_plugin
+from polywrap_client import PolywrapClient
+
+config = PolywrapClientConfigBuilder().set_package(
+    uri=Uri.from_str("plugin/logger"),
+    package=logger_plugin()
+).set_interface(
+    interface=Uri.from_str("ens/wraps.eth:[email protected]"),
+    implementations=[Uri.from_str("plugin/logger")]
+).set_redirect(
+    Uri.from_str("ens/wraps.eth:[email protected]"),
+    Uri.from_str("plugin/logger")
+).build()
+client = PolywrapClient(config)
+```
+
+### 2. Invoke The Logger
+Invocations to the logger plugin can be made via the interface URI (which will get redirected), or the plugin's URI directly:
+```python
+await client.invoke({
+  'uri': 'ens/wraps.eth:[email protected]' | 'plugin/logger',
+  'method': 'log',
+  'args': {
+    'level': 'INFO',
+    'message': 'foo bar baz'
+  }
+})
+```
+
+### 3. Customize The Logger
+When adding the logger to your client, you can add your own custom log function:
+```python
+config = PolywrapClientConfigBuilder().set_package(
+    uri=Uri.from_str("plugin/logger"),
+    package=logger_plugin(LoggerConfig(logger=YourLogger(), level=LogLevel.INFO))
+).set_interface(
+    interface=Uri.from_str("ens/wraps.eth:[email protected]"),
+    implementations=[Uri.from_str("plugin/logger")]
+).set_redirect(
+    Uri.from_str("ens/wraps.eth:[email protected]"),
+    Uri.from_str("plugin/logger")
+).build()
+```
+
+### 4. Add Multiple Loggers
+Multiple logger implementations can be added to the client:
+```python
+config = PolywrapClientConfigBuilder().set_package(
+    uri=Uri.from_str("plugin/logger"),
+    package=logger_plugin(LoggerConfig(logger=YourLogger(), level=LogLevel.INFO))
+).set_interface(
+    interface=Uri.from_str("ens/wraps.eth:[email protected]"),
+    implementations=[Uri.from_str("plugin/logger"), Uri.from_str("plugin/custom-logger")]
+).set_package(
+    uri=Uri.from_str("plugin/custom-logger"),
+    package=custom_logger_plugin()
+).build()
+```
+
+### 5. Invoke All Logger Implementations
+When you'd like to log something to more than one logger, you can invoke all implementations of the logger interface:
+```python
+implementations = client.get_implementations('ens/wraps.eth:[email protected]')
+
+for impl in implementations:
+    await client.invoke({
+        'uri': impl,
+        'method': 'log',
+        'args': {
+            'level': 'INFO',
+            'message': 'message'
+        }
+    })
+```

packages/plugins/polywrap-logger-plugin/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@polywrap/python-logger-plugin",
+  "description": "Polywrap Python Logger Plugin",
+  "version": "0.10.1",
+  "private": true,
+  "devDependencies": {
+    "polywrap": "0.10.2"
+  },
+  "scripts": {
+    "codegen": "npx polywrap codegen -g polywrap_logger_plugin/wrap"
+  }
+}

packages/plugins/polywrap-logger-plugin/poetry.lock

@@ -0,0 +1,10 @@
+format: 0.3.0
+project:
+  name: Logger
+  type: plugin/python
+source:
+  schema: ./schema.graphql
+  module: ./polywrap_logger_plugin/__init__.py
+  import_abis:
+    - uri: wrap://ens/wraps.eth:[email protected]
+      abi: ../../interface/polywrap.graphql

packages/plugins/polywrap-logger-plugin/polywrap.yaml

@@ -0,0 +1,36 @@
+"""This package contains the Logger plugin."""
+import logging
+from dataclasses import dataclass, field
+
+from polywrap_plugin import PluginPackage
+
+from .wrap import ArgsLog, InvokerClient, LogLevel, Module, manifest
+
+
+@dataclass
+class LoggerConfig:
+    """Defines the configuration for the Logger plugin."""
+
+    logger: logging.Logger = field(default_factory=logging.getLogger)
+    level: LogLevel = LogLevel.INFO
+
+
+class LoggerModule(Module[LoggerConfig]):
+    """Defines the Logger module."""
+
+    def __init__(self, config: LoggerConfig):
+        """Initializes the Logger module."""
+        self.config = config
+        self.logger = self.config.logger
+        self.logger.setLevel(self.config.level.name)
+
+    def log(self, args: ArgsLog, client: InvokerClient, env: None) -> bool:
+        """Logs a message."""
+        level = (args["level"].value + 1) * 10
+        self.logger.log(level, args["message"])
+        return True
+
+
+def logger_plugin(config: LoggerConfig = LoggerConfig()) -> PluginPackage[LoggerConfig]:
+    """Returns the Logger plugin package."""
+    return PluginPackage(module=LoggerModule(config), manifest=manifest)

packages/plugins/polywrap-logger-plugin/polywrap_logger_plugin/__init__.py

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "polywrap-logger-plugin"
+version = "0.1.2"
+description = ""
+authors = ["Niraj <[email protected]>"]
+readme = "README.md"
+packages = [{include = "polywrap_logger_plugin"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+polywrap-plugin = "0.1.2"
+polywrap-core = "^0.1.2"
+polywrap-msgpack = "^0.1.2"
+polywrap-manifest = "^0.1.2"
+
+[tool.poetry.group.dev.dependencies]
+polywrap-client = {path = "../../polywrap-client", develop = true}
+polywrap-uri-resolvers = {path = "../../polywrap-uri-resolvers", develop = true}
+polywrap-client-config-builder = {path = "../../polywrap-client-config-builder", develop = true}
+black = "^23.1.0"
+pytest = "^7.2.1"
+pytest-asyncio = "^0.20.3"
+isort = "^5.12.0"
+bandit = "^1.7.4"
+pyright = "^1.1.296"
+pylint = "^2.16.3"
+tox = "^3.26.0"
+tox-poetry = "^0.4.1"
+pytest-mock = "^3.10.0"
+pydocstyle = "^6.3.0"
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+
+[tool.black]
+target-version = ["py310"]
+exclude = "polywrap_logger_plugin/wrap/*"
+
+[tool.pyright]
+typeCheckingMode = "strict"
+reportShadowedImports = false
+exclude = [
+    "**/wrap/"
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = [
+    "tests",
+]
+
+[tool.pylint]
+disable = [
+    "too-many-return-statements",
+    "unused-argument",
+    "invalid-name",
+    "too-few-public-methods",
+]
+ignore-paths = [
+    "polywrap_logger_plugin/wrap"
+]
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+skip = ["polywrap_logger_plugin/wrap"]
+
+[tool.pydocstyle]
+# default

packages/plugins/polywrap-logger-plugin/polywrap_logger_plugin/py.typed

@@ -0,0 +1 @@
+#import * from "ens/wraps.eth:[email protected]"

packages/plugins/polywrap-logger-plugin/pyproject.toml

@@ -0,0 +1,12 @@
+import logging
+import pytest
+from polywrap_logger_plugin import LoggerConfig, LogLevel
+from typing import Callable
+
+
+@pytest.fixture
+def valid_logger_config() -> Callable[[LogLevel], LoggerConfig]:
+    def _valid_logger_config(level: LogLevel) -> LoggerConfig:
+        return LoggerConfig(logger=logging.getLogger("test_logger"), level=level)
+    return _valid_logger_config
+

packages/plugins/polywrap-logger-plugin/schema.graphql

@@ -0,0 +1,20 @@
+import pytest
+
+from polywrap_client import PolywrapClient
+from polywrap_core import Uri
+from polywrap_uri_resolvers import FsUriResolver, SimpleFileReader
+from polywrap_client_config_builder import PolywrapClientConfigBuilder
+from polywrap_logger_plugin import logger_plugin
+
+@pytest.fixture
+def builder():
+    return PolywrapClientConfigBuilder().add_resolver(
+        FsUriResolver(file_reader=SimpleFileReader())
+    ).set_package(
+        Uri.from_str("plugin/logger"), logger_plugin()
+    )
+
+@pytest.fixture
+def client(builder: PolywrapClientConfigBuilder):
+    config = builder.build()
+    return PolywrapClient(config)

packages/plugins/polywrap-logger-plugin/tests/__init__.py

@@ -0,0 +1,30 @@
+import logging
+from polywrap_client import PolywrapClient
+from polywrap_core import Uri
+import pytest
+from polywrap_logger_plugin import LogLevel
+from _pytest.logging import LogCaptureFixture
+
+
+@pytest.mark.parametrize("log_level", list(LogLevel))
+async def test_log_levels(
+    client: PolywrapClient,
+    caplog: LogCaptureFixture,
+    log_level: LogLevel,
+):
+    caplog.set_level(logging.DEBUG)
+    args_log = dict(message="Test message", level=log_level)
+
+    assert client.invoke(
+        uri=Uri.from_str("plugin/logger"),
+        method="log",
+        args=args_log,
+    )
+    last_record = caplog.records[-1] if caplog.records else None
+
+    if log_level >= LogLevel.INFO:
+        assert last_record
+        assert last_record.levelno == (log_level.value + 1) * 10
+        assert last_record.message == "Test message"
+    else:
+        assert last_record is None

packages/plugins/polywrap-logger-plugin/tests/conftest.py

@@ -0,0 +1,29 @@
+import logging
+from polywrap_core import InvokerClient
+import pytest
+from polywrap_logger_plugin import LoggerConfig, LoggerModule, ArgsLog, LogLevel
+from _pytest.logging import LogCaptureFixture
+from typing import Callable, cast
+
+
+@pytest.mark.parametrize("config_level", list(LogLevel))
+@pytest.mark.parametrize("log_level", list(LogLevel))
+async def test_log_levels(
+    caplog: LogCaptureFixture,
+    valid_logger_config: Callable[[LogLevel], LoggerConfig],
+    config_level: LogLevel,
+    log_level: LogLevel,
+):
+    caplog.set_level(logging.DEBUG)
+    logger_module = LoggerModule(valid_logger_config(config_level))
+    args_log = ArgsLog(message="Test message", level=log_level)
+
+    assert logger_module.log(args_log, cast(InvokerClient, None), None)
+    last_record = caplog.records[-1] if caplog.records else None
+
+    if log_level.value >= config_level.value:
+        assert last_record
+        assert last_record.levelno == (log_level.value + 1) * 10
+        assert last_record.message == "Test message"
+    else:
+        assert last_record is None

packages/plugins/polywrap-logger-plugin/tests/integration/__init__.py

@@ -0,0 +1,29 @@
+[tox]
+isolated_build = True
+envlist = py310
+
+[testenv]
+commands =
+    pytest tests/
+
+[testenv:lint]
+commands =
+    isort --check-only polywrap_logger_plugin
+    black --check polywrap_logger_plugin
+    pylint polywrap_logger_plugin
+
+[testenv:typecheck]
+commands = 
+    pyright polywrap_logger_plugin
+
+[testenv:secure]
+commands = 
+    bandit -r polywrap_logger_plugin -c pyproject.toml
+
+[testenv:dev]
+basepython = python3.10
+usedevelop = True
+commands = 
+    isort polywrap_logger_plugin
+    black polywrap_logger_plugin
+