Merge pull request #115 from polywrap/nk/readme

feat: add readme for every packages

Author: Niraj-Kamdar

packages/polywrap-client-config-builder/README.md

@@ -1,14 +1,64 @@
+# polywrap-client-config-builder
 
-# Polywrap Python Client
-## This object allows you to build proper Polywrapt ClientConfig objects
+A utility class for building the PolywrapClient config. 
 
-These objects are needed to configure your python client's wrappers, pluggins, env variables, resolvers and interfaces.
+Supports building configs using method chaining or imperatively.
 
-Look at [this file](./polywrap_client_config_builder/client_config_builder.py) to detail all of its functionality
-And at [tests](./tests/test_client_config_builder.py)
+## Quickstart
 
----
+### Initialize
 
-The current implementation uses the `ClientConfig` as a dataclass to later create an Abstract Base Class of a `BaseClientConfigBuilder` which defines more clearly the functions of the module, like add_envs, set_resolvers, remove_wrappers, and so on.  
+Initialize a ClientConfigBuilder using the constructor
 
-This `BaseClientConfigBuilder` is later used in the class `ClientConfigBuilder` which only implements the build method, for now, and inherits all the abstract methods of the `BaseClientConfigBuilder`.
+```python
+# start with a blank slate (typical usage)
+builder = ClientConfigBuilder()
+```
+
+### Configure
+
+Add client configuration with add, or flexibly mix and match builder configuration methods to add and remove configuration items.
+
+```python
+# add multiple items to the configuration using the catch-all `add` method
+builder.add(
+    BuilderConfig(
+        envs={},
+        interfaces={},
+        redirects={},
+        wrappers={},
+        packages={},
+        resolvers=[]
+    )
+)
+
+// add or remove items by chaining method calls
+builder
+    .add_package("wrap://plugin/package", test_plugin({}))
+    .remove_package("wrap://plugin/package")
+    .add_packages(
+      {
+        "wrap://plugin/http": http_plugin({}),
+        "wrap://plugin/filesystem": file_system_plugin({}),
+      }
+    )
+```
+
+### Build
+
+Finally, build a ClientConfig to pass to the PolywrapClient constructor.
+
+```python
+# accepted by the PolywrapClient
+config = builder.build()
+
+# build with a custom cache
+config = builder.build({
+  wrapperCache: WrapperCache(),
+})
+
+# or build with a custom resolver
+coreClientConfig = builder.build({
+  resolver: RecursiveResolver(...),
+})
+```

packages/polywrap-client/README.md

@@ -1 +1,40 @@
-TODO
+# polywrap-client
+
+Python implementation of the polywrap client.
+
+## Usage
+
+### Configure and Instantiate
+
+Use the `polywrap-uri-resolvers` package to configure resolver and build config for the client.
+
+```python
+from polywrap_uri_resolvers import FsUriResolver, SimpleFileReader
+
+config = ClientConfig(
+    resolver=FsUriResolver(file_reader=SimpleFileReader())
+)
+
+client = PolywrapClient(config)
+```
+
+### Invoke
+
+Invoke a wrapper.
+
+```python
+uri = Uri.from_str(
+    'fs/<path to wrapper>'  # Example uses simple math wrapper
+)
+args = {
+    "arg1": "123",  # The base number
+    "obj": {
+        "prop1": "1000",  # multiply the base number by this factor
+    },
+}
+options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+    uri=uri, method="method", args=args, encode_result=False
+)
+result = await client.invoke(options)
+assert result == "123000"
+```

packages/polywrap-core/README.md

@@ -1 +1,3 @@
-TODO
+# polywrap-core
+
+A Python implementation of the WRAP standard, including all fundamental types & algorithms.

packages/polywrap-core/poetry.lock

@@ -10,11 +10,8 @@ authors = ["Cesar <cesar@polywrap.io>", "Niraj <niraj@polywrap.io>"]
 
 [tool.poetry.dependencies]
 python = "^3.10"
-gql = "3.4.0"
-graphql-core = "^3.2.1"
 polywrap-manifest = { path = "../polywrap-manifest", develop = true }
 polywrap-msgpack = { path = "../polywrap-msgpack", develop = true }
-pydantic = "^1.10.2"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.1.2"

packages/polywrap-core/pyproject.toml

@@ -0,0 +1,17 @@
+# polywrap-manifest
+
+Python implementation of the WRAP manifest schema at https://github.com/polywrap/wrap
+
+## Usage
+
+### Deserialize WRAP manifest
+
+```python
+from polywrap_manifest import deserialize_wrap_manifest, WrapManifest_0_1
+
+with open("<path to WRAP package>/wrap.info", "rb") as f:
+    raw_manifest = f.read()
+
+manifest = deserialize_wrap_manifest(raw_manifest)
+assert isinstance(manifest, WrapManifest_0_1)
+```

packages/polywrap-manifest/README.md

@@ -0,0 +1,41 @@
+# polywrap-msgpack
+
+Python implementation of the WRAP MsgPack encoding standard.
+
+## Usage
+
+### Encoding-Decoding Native types and objects
+
+```python
+from polywrap_msgpack import msgpack_decode, msgpack_encode
+
+dictionary = {
+  "foo": 5,
+  "bar": [True, False],
+  "baz": {
+    "prop": "value"
+  }
+}
+
+encoded = msgpack_encode(dictionary)
+decoded = msgpack_decode(encoded)
+
+assert dictionary == decoded
+```
+
+### Encoding-Decoding Extension types
+
+```python
+from polywrap_msgpack import msgpack_decode, msgpack_encode, GenericMap
+
+counter: GenericMap[str, int] = GenericMap({
+  "a": 3,
+  "b": 2,
+  "c": 5
+})
+
+encoded = msgpack_encode(counter)
+decoded = msgpack_decode(encoded)
+
+assert counter == decoded
+```

packages/polywrap-msgpack/README.md

@@ -0,0 +1,36 @@
+# polywrap-wasm
+
+Python implementation of the plugin wrapper runtime.
+
+## Usage
+
+### Invoke Plugin Wrapper
+
+```python
+from typing import Any, Dict, List, Union, Optional
+from polywrap_manifest import AnyWrapManifest
+from polywrap_plugin import PluginModule
+from polywrap_core import Invoker, Uri, InvokerOptions, UriPackageOrWrapper, Env
+
+class GreetingModule(PluginModule[None]):
+    def __init__(self, config: None):
+        super().__init__(config)
+
+    def greeting(self, args: Dict[str, Any], client: Invoker[UriPackageOrWrapper], env: Optional[Env] = None):
+        return f"Greetings from: {args['name']}"
+
+manifest = cast(AnyWrapManifest, {})
+wrapper = PluginWrapper(greeting_module, manifest)
+args = {
+    "name": "Joe"
+}
+options: InvokeOptions[UriPackageOrWrapper] = InvokeOptions(
+    uri=Uri.from_str("ens/greeting.eth"),
+    method="greeting",
+    args=args
+)
+invoker: Invoker = ...
+
+result = await wrapper.invoke(options, invoker)
+assert result, "Greetings from: Joe"
+```

packages/polywrap-plugin/README.md

@@ -1 +1,4 @@
-TODO
+# polywrap-uri-resolvers
+
+URI resolvers to customize URI resolution in the Polywrap Client.
+

packages/polywrap-uri-resolvers/README.md

@@ -1 +1,29 @@
-TODO
+# polywrap-wasm
+
+Python implementation of the Wasm wrapper runtime.
+
+## Usage
+
+### Invoke Wasm Wrapper
+
+```python
+from typing import cast
+from polywrap_manifest import AnyWrapManifest
+from polywrap_core import FileReader, Invoker
+from polywrap_wasm import WasmWrapper
+
+file_reader: FileReader = ... # any valid file_reader, pass NotImplemented for mocking
+wasm_module: bytes = bytes("<wrapper wasm module bytes read from file or http>")
+wrap_manifest: AnyWrapManifest = ...
+wrapper = WasmWrapper(file_reader, wasm_module, wrap_manifest)
+invoker: Invoker = ... # any valid invoker, mostly PolywrapClient
+
+message = "hey"
+args = {"arg": message}
+options: InvokeOptions[UriPackageOrWrapper] = InvokeOptions(
+  uri=Uri.from_str("fs/./build"), method="simpleMethod", args=args
+)
+result = await wrapper.invoke(options, invoker)
+assert result.encoded is True
+assert msgpack_decode(cast(bytes, result.result)) == message
+```