@asyncapi/generator 2.8.0 → 2.8.2

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/ClientClass.js

@@ -0,0 +1,47 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+import { getClientName, getServerUrl, getServer, getQueryParams, getTitle } from '@asyncapi/generator-helpers';
+import { Constructor } from './Constructor';
+import { Connect } from './Connect';
+import { RegisterErrorHandler } from './RegisterErrorHandler';
+import { HandleMessage } from './HandleMessage';
+import { SendOperation } from './SendOperation';
+import { Send } from './Send';
+import { CloseConnection, RegisterMessageHandler } from '@asyncapi/generator-components';
+import { RegisterOutgoingProcessor } from './RegisterOutgoingProcessor';
+import { HandleError } from './HandleError';
+
+export function ClientClass({ asyncapi, params }) {
+  const server = getServer(asyncapi.servers(), params.server);
+  const title = getTitle(asyncapi);
+  const queryParams = getQueryParams(asyncapi.channels());
+  const clientName = getClientName(asyncapi, params.appendClientSuffix, params.customClientName);
+  const serverUrl = getServerUrl(server);
+  const operations = asyncapi.operations();
+  const sendOperations = operations.filterBySend();
+  return (
+    <Text>
+      <Text newLines={2}>
+        {`class ${clientName}:`}
+      </Text>
+      <Constructor serverUrl={serverUrl} query={queryParams} />
+      <Connect title={title} />
+      <RegisterMessageHandler
+        language="python"
+        methodName='register_message_handler'
+        methodParams={['self', 'handler']}
+        preExecutionCode='"""Register a callable to process incoming messages."""'
+      />
+      <RegisterErrorHandler />
+      <RegisterOutgoingProcessor />
+      <HandleMessage />
+      <HandleError />
+      <SendOperation sendOperations={sendOperations} clientName={clientName} />
+      <Send sendOperations={sendOperations} />
+      <CloseConnection 
+        language="python" 
+        methodParams={['self']}
+        preExecutionCode='"""Cleanly close the WebSocket connection."""'
+      />
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/Connect.js

@@ -0,0 +1,49 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function Connect({ title }) {
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `def on_open(self, ws):
+    print("Connected to ${title} server")
+
+def on_message(self, ws, message):
+    self.handle_message(message)
+
+def on_error(self, ws, error):
+    print("WebSocket Error:", error)
+    self.handle_error(error)
+
+def on_close(self, ws, close_status_code, close_msg):
+    print("Disconnected from ${title}", close_status_code, close_msg)
+
+def connect(self):
+    """Establish the connection and start the run_forever loop in a background thread."""
+    ssl_opts = {"ca_certs": certifi.where()}
+    self.ws_app = websocket.WebSocketApp(
+        self.url,
+        on_open=self.on_open,
+        on_message=self.on_message,
+        on_error=self.on_error,
+        on_close=self.on_close
+    )
+    # Run the WebSocketApp's run_forever in a separate thread with multithreading enabled.
+    def run():
+
+        retry = 0
+        max_retries = 5
+        
+        while not self._stop_event.is_set() and retry < max_retries:
+            try:
+                retry += 1
+                print("Starting WebSocket thread...")
+                self.ws_app.run_forever(sslopt=ssl_opts)
+            except Exception as e:
+                print(f"Exception in WebSocket thread: {e}")  # Print full error details
+
+    thread = threading.Thread(target=run, daemon=True)
+    thread.start()`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/Constructor.js

@@ -0,0 +1,42 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+import { QueryParamsVariables } from './QueryParamsVariables';
+import { QueryParamsArgumentsDocs } from './QueryParamsArgumentsDocs';
+import { InitSignature } from './InitSignature';
+
+export function Constructor({ serverUrl, query}) {
+  const queryParamsArray = query && Array.from(query.entries());
+  
+  return (
+    <>
+      <InitSignature queryParams={queryParamsArray} serverUrl={serverUrl} />
+      <Text indent={2}>
+        {`
+      """
+      Constructor to initialize the WebSocket client.
+
+      Args:
+          url (str, optional): The WebSocket server URL. Use it if the server URL is 
+          different from the default one taken from the AsyncAPI document.`}
+      </Text>
+      <QueryParamsArgumentsDocs queryParams={queryParamsArray} />
+      <Text indent={2}>
+        {`
+      """
+      self.ws_app = None  # Instance of WebSocketApp
+      self.message_handlers = []      # Callables for incoming messages
+      self.error_handlers = []        # Callables for errors
+      self.outgoing_processors = []   # Callables to process outgoing messages
+      self._stop_event = threading.Event()
+      
+      ${ query ? 'params = {}' : ''}`
+        }
+      </Text>
+      <QueryParamsVariables queryParams={queryParamsArray} />
+      <Text newLines={2}>
+        {`
+        ${query ? 'qs = urlencode(params) if params else ""' : ''}
+        ${query ? 'self.url = f"{url}{f\'?{qs}\' if qs else \'\'}"' : 'self.url = url'}`}
+      </Text>
+    </>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/HandleError.js

@@ -0,0 +1,18 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function HandleError() {
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `def handle_error(self, error):
+    """Pass the error to all registered error handlers. Generic log message is printed if no handlers are registered."""
+    if len(self.error_handlers) == 0:
+      print("\\033[91mError occurred:\\033[0m", error)
+    else:
+      # Call custom error handlers
+      for handler in self.error_handlers:
+        handler(error)`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/HandleMessage.js

@@ -0,0 +1,17 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function HandleMessage() {
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `def handle_message(self, message):
+    """Pass the incoming message to all registered message handlers. """
+    if len(self.message_handlers) == 0:
+      print("\\033[94mReceived raw message:\\033[0m", message)
+    else:
+      for handler in self.message_handlers:
+        handler(message)`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/InitSignature.js

@@ -0,0 +1,24 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function InitSignature({ queryParams, serverUrl }) {
+  if (!queryParams) {
+    return (
+      <Text indent={2} newLines={2}>
+        {`def __init__(self, url: str = "${serverUrl}"):`}
+      </Text>
+    );
+  }
+  
+  const queryParamsArguments = queryParams?.map((param) => {
+    const paramName = param[0];
+    const paramDefaultValue = param[1];
+    const defaultValue = paramDefaultValue ? `"${paramDefaultValue}"` : 'None';
+    return `${paramName}: str = ${defaultValue}`;
+  }).join(', ');
+  
+  return (
+    <Text indent={2} newLines={2}>
+      {`def __init__(self, url: str = "${serverUrl}", ${queryParamsArguments}):`}
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/QueryParamsArgumentsDocs.js

@@ -0,0 +1,19 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function QueryParamsArgumentsDocs({ queryParams }) {
+  if (!queryParams) {
+    return null;
+  }
+
+  return queryParams.map((param) => {
+    const paramName = param[0];
+    const firstLine = `${paramName} (str, optional):`;
+    const secondLine = `If provided (or if ${paramName.toUpperCase()} environment variable is set), added as ?${paramName}=… to URL`;
+    return (
+      <Text indent={1}>
+        {firstLine}
+        {secondLine}
+      </Text>
+    );
+  });
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/QueryParamsVariables.js

@@ -0,0 +1,27 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function QueryParamsVariables({ queryParams }) {
+  if (!queryParams) {
+    return null;
+  }
+
+  return queryParams.map((param) => {
+    const paramName = param[0];
+    const variableDefinition = `${paramName} = ${paramName} or os.getenv("${paramName.toUpperCase()}")`;
+    const ifQueryProvided = `if ${paramName} is not None:`;
+    const assignment = `params["${paramName}"] = ${paramName}`;
+    return (
+      <>
+        <Text indent={8}>
+          {variableDefinition}
+        </Text>
+        <Text indent={8}>
+          {ifQueryProvided}
+        </Text>
+        <Text indent={10}>
+          {assignment}
+        </Text>
+      </>
+    );
+  });
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/RegisterErrorHandler.js

@@ -0,0 +1,16 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function RegisterErrorHandler() {
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `def register_error_handler(self, handler):
+    """Register a callable to process errors."""
+    if callable(handler):
+        self.error_handlers.append(handler)
+    else:
+        print("Error handler must be callable")`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/RegisterOutgoingProcessor.js

@@ -0,0 +1,19 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function RegisterOutgoingProcessor() {
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `def register_outgoing_processor(self, processor):
+    """
+    Register a callable that processes outgoing messages automatically.
+    These processors run in sequence before each message is sent.
+    """
+    if callable(processor):
+        self.outgoing_processors.append(processor)
+    else:
+        print("Outgoing processor must be callable")`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/Requires.js

@@ -0,0 +1,15 @@
+import { DependencyProvider } from '@asyncapi/generator-components';
+
+export function Requires({ query }) {
+  const additionalDependencies = [];
+  if (query) {
+    additionalDependencies.push('import os');
+    additionalDependencies.push('from urllib.parse import urlencode');
+  }
+  return (
+    <DependencyProvider
+      language="python"
+      additionalDependencies={additionalDependencies}
+    />
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/Send.js

@@ -0,0 +1,33 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+
+export function Send({ sendOperations }) {
+  if (!sendOperations || sendOperations.length === 0) {
+    return null;
+  }
+
+  return (
+    <Text newLines={2} indent={2}>
+      {
+        `
+@staticmethod
+async def _send(message, socket):
+    """
+    Internal helper to handle the actual sending logic.
+
+    Args:
+        message (dict or str): The message to send.
+        socket (websockets.WebSocketCommonProtocol): The WebSocket to send through.
+
+    Notes:
+        If message is a dictionary, it will be automatically converted to JSON.
+    """
+    try:
+        if isinstance(message, dict):
+            message = json.dumps(message)
+        await socket.send(message)
+    except Exception as e:
+        print("Error sending:", e)`
+      }
+    </Text>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/components/SendOperation.js

@@ -0,0 +1,50 @@
+import { Text } from '@asyncapi/generator-react-sdk';
+import { toSnakeCase } from '@asyncapi/generator-helpers';
+
+export function SendOperation({ sendOperations, clientName }) {
+  if (!sendOperations || sendOperations.length === 0) {
+    return null;
+  }
+
+  return (
+    <>
+      {
+        sendOperations.map((operation) => {
+          const methodName = toSnakeCase(operation.id());
+          const staticMethodName = `${methodName}_static`;
+          
+          return (
+            <Text newLines={2} indent={2}>
+              {`async def ${methodName}(self, message):
+    """
+    Send a ${methodName} message using the WebSocket connection attached to this instance.
+
+    Args:
+        message (dict or str): The message to send. Will be serialized to JSON if it's a dictionary.
+
+    Raises:
+        Exception: If sending fails or the socket is not connected.
+    """
+    await self._send(message, self.ws_app)
+
+@staticmethod
+async def ${staticMethodName}(message, socket):
+    """
+    Send a ${methodName} message using a provided WebSocket connection, without needing an instance.
+
+    Args:
+        message (dict or str): The message to send.
+        socket (websockets.WebSocketCommonProtocol): The WebSocket to send through.
+
+    Raises:
+        Exception: If sending fails or the socket is not connected.
+    """
+    await ${clientName}._send(message, socket)
+`}
+            </Text>
+          );
+        })
+      }
+    </>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/example-slack.py

@@ -0,0 +1,21 @@
+import sys
+import os
+import time
+
+sys.path.append(os.path.join(os.path.dirname(__file__), 'test'))
+
+from temp.snapshotTestResult.client_slack.client import SlackWebsocketAPIClient
+
+def custom_message_handler(message):
+    print(f"\033[94mIncomming event from Slack\033[0m: {message}")
+
+def main():
+    client = SlackWebsocketAPIClient()
+    client.register_message_handler(custom_message_handler)
+
+    client.connect()
+
+    # Keep program alive for a while to allow message processing
+    time.sleep(1000)
+
+main()

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/example.py

@@ -0,0 +1,41 @@
+import sys
+import os
+import time
+
+sys.path.append(os.path.join(os.path.dirname(__file__), 'test'))
+
+from temp.snapshotTestResult.custom_client_hoppscotch.client import HoppscotchClient
+
+def custom_message_handler(message):
+    print(f"\033[94mCustom processing of received message\033[0m: {message}")
+
+def custom_error_handler(error):
+    print(f"Custom error handling: {error}")
+
+def outgoing_message_processor(message):
+    # Modify message before sending (e.g., add a timestamp)
+    print(f"\033[92mCustom processing of outgoing message\033[0m: {message}")
+    return {"Processed outgoing message": message, "timestamp": "2025-03-13T12:00:00Z"}
+
+def main():
+    client = HoppscotchClient()
+    client.register_message_handler(custom_message_handler)
+    client.register_error_handler(custom_error_handler)
+    client.register_outgoing_processor(outgoing_message_processor)
+
+    client.connect()
+    
+    # Give some time for the connection to establish
+    time.sleep(2)
+
+    # Send multiple messages to test stream handling
+    for i in range(5):
+        message = f'Hello, Echo Yo! {i}'
+        client.send_echo_message(message)
+        time.sleep(2)  # Wait for a response
+
+    # Keep program alive for a while to allow message processing
+    time.sleep(10)
+
+main()
+

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "core-template-client-websocket-python",
+  "private": true,
+  "description": "This is a template generating Python websocket client",
+  "scripts": {
+    "test": "jest --coverage",
+    "test:update": "npm run test -- -u",
+    "lint": "eslint --max-warnings 0 --config ../../../../../.eslintrc --ignore-path ../../../../../.eslintignore .",
+    "lint:fix": "eslint --fix --max-warnings 0 --config ../../../../../.eslintrc --ignore-path ../../../../../.eslintignore ."
+  },
+  "author": "Lukasz Gornicki <lpgornicki@gmail.com>",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@asyncapi/generator-react-sdk": "*",
+    "@asyncapi/generator-helpers": "1.0.0"
+  },
+  "devDependencies": {
+    "@asyncapi/parser": "^3.0.14",
+    "@babel/cli": "^7.25.9",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-react": "^7.25.9",
+    "jest-esm-transformer": "^1.0.0",
+    "eslint": "^6.8.0",
+    "eslint-plugin-jest": "^23.8.2",
+    "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-sonarjs": "^0.5.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "jsx"
+    ],
+    "transform": {
+      "^.+\\.jsx?$": "babel-jest"
+    },
+    "moduleNameMapper": {
+      "^nimma/legacy$": "<rootDir>/../../../../../node_modules/nimma/dist/legacy/cjs/index.js",
+      "^nimma/(.*)": "<rootDir>/../../../../../node_modules/nimma/dist/cjs/$1"
+    }
+  },
+  "babel": {
+    "presets": [
+      "@babel/preset-env",
+      [
+        "@babel/preset-react",
+        {
+          "runtime": "automatic"
+        }
+      ]
+    ]
+  }
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/template/client.py.js

@@ -0,0 +1,23 @@
+import { File } from '@asyncapi/generator-react-sdk';
+import { getServer, getQueryParams, getInfo } from '@asyncapi/generator-helpers';
+import { FileHeaderInfo } from '@asyncapi/generator-components';
+import { Requires } from '../components/Requires';
+import { ClientClass } from '../components/ClientClass';
+
+export default function ({ asyncapi, params }) {
+  const server = getServer(asyncapi.servers(), params.server);
+  const info = getInfo(asyncapi);
+  const queryParams = getQueryParams(asyncapi.channels());
+  return (
+    // The clientFileName default values can be found and modified under the .ageneratorrc
+    <File name={params.clientFileName}>
+      <FileHeaderInfo
+        info={info}
+        server={server}
+        language="python"
+      />
+      <Requires query={queryParams} />
+      <ClientClass asyncapi={asyncapi} params={params} />
+    </File>
+  );
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/template/models.js

@@ -0,0 +1,5 @@
+import { Models } from '@asyncapi/generator-components';
+
+export default async function({ asyncapi }) {
+  return await Models({ asyncapi });
+}

package/lib/templates/bakedInTemplates/core-template-client-websocket-python/template/requirements.txt.js

@@ -0,0 +1,13 @@
+import { File, Text } from '@asyncapi/generator-react-sdk';
+
+export default function () {
+  return (
+    <File name="requirements.txt">
+      <Text>
+        {`websocket-client==1.8.0
+certifi==2025.1.31
+requests==2.32.3`}
+      </Text>
+    </File>
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -26,8 +26,9 @@
     "generate:assets": "npm run docs && npm run generate:readme:toc",
     "bump:version": "npm --no-git-tag-version --allow-same-version version $VERSION",
     "build": "node scripts/build-templates.js",
-    "pretest": "npm run build",
-    "prepublish": "npm run build"
+    "build:reactsdk": "cd ../react-sdk && npm run build",
+    "pretest": "npm run build:reactsdk && npm run build",
+    "prepublishOnly": "npm run pretest"
   },
   "preferGlobal": true,
   "bugs": {