fix up minor inconsistencies, add python to quickstart

Author: pileks

docusaurus.config.js

@@ -150,8 +150,9 @@ const config = {
         darkTheme: darkCodeTheme,
         additionalLanguages: [
           "rust",
-          "swift",
-          "kotlin"
+          "python",
+          "kotlin",
+          "swift"
         ]
       },
     }),

package.json

@@ -72,7 +72,7 @@
   },
   "doc-snippets": {
     "extract": {
-      "include": "./**/*.{ts,tsx,js,json,yaml,txt,md,graphql,cue,kt,kts}",
+      "include": "./**/*.{ts,tsx,js,json,yaml,txt,md,graphql,cue,kt,kts,py}",
       "ignore": [
         "./**/node_modules/**",
         "./**/.polywrap/**",

sidebars.js

@@ -20,6 +20,7 @@ const sidebars = {
       label: 'Quick Start',
       items: [
         'quick-start/javascript',
+        'quick-start/python',
         'quick-start/kotlin',
         'quick-start/swift',
       ]

snippets/quick-start/py/program.py

@@ -0,0 +1,67 @@
+# $start: quickstart-py-import-init-client
+from polywrap import (
+    Uri,  # Required to construct a valid wrap URI
+    PolywrapClient,  # The client itself
+    PolywrapClientConfigBuilder,
+    sys_bundle,
+    web3_bundle,
+)
+
+builder = PolywrapClientConfigBuilder().add_bundle(sys_bundle).add_bundle(web3_bundle)
+
+config = builder.build()
+
+client = PolywrapClient(config)
+# $end
+
+# $start: quickstart-py-invoke-client
+result = client.invoke(
+    uri=Uri.from_str("wrapscan.io/polywrap/sha3@1"),
+    method="sha3_256",
+    args={
+        "message": "Hello Polywrap!",
+    },
+    encode_result=False,
+)
+
+print(result)
+# $end
+
+# $start: quickstart-py-uniswap
+wethResult = client.invoke(
+    uri=Uri.from_str("wrapscan.io/polywrap/uniswap-v3@1"),
+    method="fetchToken",
+    args={
+        "address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        "chainId": "MAINNET",
+    },
+    encode_result=False,
+)
+
+print(wethResult)
+
+usdcResult = client.invoke(
+    uri=Uri.from_str("wrapscan.io/polywrap/uniswap-v3@1"),
+    method="fetchToken",
+    args={
+        "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        "chainId": "MAINNET",
+    },
+    encode_result=False,
+)
+
+print(usdcResult)
+
+poolAddressResult = client.invoke(
+    uri=Uri.from_str("wrapscan.io/polywrap/uniswap-v3@1"),
+    method="getPoolAddress",
+    args={
+        "tokenA": wethResult,
+        "tokenB": usdcResult,
+        "fee": "MEDIUM",
+    },
+    encode_result=False,
+)
+
+print(poolAddressResult)
+# $end

src/docs/quick-start/javascript.md

@@ -64,7 +64,7 @@ At the top of your `index.js` file, import the `PolywrapClient` and instantiate
 $snippet: quickstart-js-init-client
 ```
 
-At this point, you can already invoke Wraps! In the simple example below, we will invoke the Logger Wrap within our `main` function:
+At this point, you can already invoke Wraps! In the simple example below, we will invoke the SHA3 Wrap within our `main` function:
 
 ```javascript
 $snippet: quickstart-js-1st-invoke

src/docs/quick-start/kotlin.md

@@ -51,7 +51,7 @@ You can now instantiate the Polywrap Client with a default configuration within
 $snippet: quickstart-kt-init-client
 ```
 
-At this point, you can already invoke Wraps! In the simple example below, we will invoke the Logger Wrap within our `main` function:
+At this point, you can already invoke Wraps! In the simple example below, we will invoke the SHA3 Wrap within our `main` function:
 
 ```kotlin title="App.kt"
 $snippet: quickstart-kt-invoke-client

src/docs/quick-start/python.md

@@ -9,87 +9,38 @@ To use [Wraps](/concepts/wraps) in your app, all you need is the [Polywrap Clien
 
 ### NodeJS application boilerplate
 
-We'll be using a simple NodeJS application boilerplate for this guide.
-
-Using `npm init` or `yarn init` within a directory initialize an empty NodeJS project.
-
-Within `package.json`, change the `type` of the project to `"module"`. This is not required as you can also use `require`.
-
-```json title="package.json"
-{
-  "name": "my-app-name",
-  //...
-  "type": "module",
-  //...
-}
-```
-
-Add an `index.js` file with the following code:
-
-```javascript title="index.js"
-async function main() {
-  // your code goes here...
-}
-
-main()
-  .then(() => {
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
-
-```
+We'll be using a simple empty python file named `program.py` as our boilerplate.
 
 ### Install the Polywrap Client
 
-Using `NPM`:
-```
-npm install --save @polywrap/client-js
-```
-
-Using `yarn`:
+You can install the Polywrap client using `pip`:
 ```
-yarn add @polywrap/client-js
+pip install polywrap
 ```
 
 ### Invoking your first Wrap
 
 In order to invoke a Wrap, we first need to instantiate the Polywrap Client:
 
-At the top of your `index.js` file, import the `PolywrapClient` and instantiate it:
+At the top of your `program.py` file, import the `PolywrapClient` and instantiate it:
 
-```javascript title="index.js"
-import { PolywrapClient } from "@polywrap/client-js";
-
-const client = new PolywrapClient();
+```python title="program.py"
+$snippet: quickstart-py-import-init-client
 ```
 
-At this point, you can already invoke Wraps! In the simple example below, we will invoke the Logger Wrap within our `main` function:
-
-```javascript
-const result = await client.invoke({
-  uri: "wrapscan.io/polywrap/sha3@1.0",
-  method: "sha3_256",
-  args: {
-    message: "Hello Polywrap!",
-  },
-});
+At this point, you can already invoke Wraps! In the simple example below, we will invoke the SHA3 Wrap:
 
-console.log(result);
+```python title="program.py"
+$snippet: quickstart-py-invoke-client
 ```
 
-Running the application using `node index.js`, you should now see the following appear in your console:
+Running the application using `python program.py`, you should now see the following appear in your console:
 
 ```
-{
-  ok: true,
-  value: 'ba5a5d5fb7674f5975f0ecd0cd9a2f4bcadc9c04f5ac2ab3a887d8f10355fc38'
-}
+ba5a5d5fb7674f5975f0ecd0cd9a2f4bcadc9c04f5ac2ab3a887d8f10355fc38
 ```
 
-Here we can see the structure of the `InvokeResult` object. It's `ok` field denotes whether the Wrap's invocation was successful, and the `value` is the return value of the invocation.
+This is the return value of our invocation.
 
 #### What's going on here?
 
@@ -99,14 +50,12 @@ Under the hood, through a process we call URI Resolution, the Polywrap Client kn
 
 The `PolywrapClient` comes pre-configured with everything you need for most Web2 and Web3 use-cases by default.
 
-#### The `InvokeResult` object
-
-The `InvokeResult` object can have one of two structures:
+#### Invocation return value
 
-- A successful Wrap invocation returns `{ ok: true, value: ... }` with `value` being the return value of the Wrap invocation. This can be anything - a boolean value, a string, an object, etc.
-- A failed Wrap invocation returns `{ ok: false, error: ... }` with `error` describing the reason for invocation failure.
+Invoking a wrap can result in one of two scenarios:
 
-Although not particularly useful in our last example, our next example leverages the fact that Wrap invocations return a value.
+- A successful Wrap invocation returns the return value of the Wrap invocation. This can be anything - a boolean value, a string, an object, etc.
+- A failed Wrap invocation throws an exception describing the reason for invocation failure.
 
 ### Universal SDKs
 
@@ -120,58 +69,8 @@ Now we'll invoke the Uniswap V3 Wrap which is a port of the Uniswap SDK, but wri
 
 We can use the Uniswap Wrap to fetch Uniswap's basic data related to the WETH and USDC tokes, find the address of the pool for those two tokens. We are also checking each result for errors.
 
-```javascript
-const wethResult = await client.invoke({
-  uri: "wrapscan.io/polywrap/uniswap-v3@1.0",
-  method: "fetchToken",
-  args: {
-    address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    chainId: "MAINNET",
-  },
-});
-
-// Log the invocation error and stop execution if the invocation fails
-if(!wethResult.ok) {
-  console.log(wethResult.error)
-  return;
-}
-
-console.log("WETH:", wethResult.value);
-
-const usdcResult = await client.invoke({
-  uri: "wrapscan.io/polywrap/uniswap-v3@1.0",
-  method: "fetchToken",
-  args: {
-    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    chainId: "MAINNET",
-  },
-});
-
-// Log the invocation error and stop execution if the invocation fails
-if(!usdcResult.ok) {
-  console.log(usdcResult.error)
-  return;
-}
-
-console.log("USDC:", usdcResult.value);
-
-const poolAddressResult = await client.invoke({
-  uri: "wrapscan.io/polywrap/uniswap-v3@1.0",
-  method: "getPoolAddress",
-  args: {
-    tokenA: wethResult.value,
-    tokenB: usdcResult.value,
-    fee: "MEDIUM"
-  },
-});
-
-// Log the invocation error and stop execution if the invocation fails
-if(!poolAddressResult.ok) {
-  console.log(poolAddressResult.error);
-  return;
-}
-
-console.log("Pool address:", poolAddressResult.value);
+```python title="program.py"
+$snippet: quickstart-py-uniswap
 ```
 
 You can see more examples on how to use the Uniswap V3 Wrap in its [docs page](https://uniswap.docs.wrappers.io/).