![\"Exploring](\"https:\/\/blog.logrocket.com\/wp-content\/uploads\/2022\/09\/exploring-jspybridge-using-python-javascript.png\")
\nNode.js and Python are two of the most popular tools for developing software. Each has its pros and cons, and sometimes it can be difficult to choose from them, depending on the task at hand. For example, the Node.js runtime is fast and has a large community with millions of packages, but it pales in comparison to Python when it comes to data science and machine learning packages.<\/p>\n
Depending on your problem, you might find yourself needing both Node.js and Python; however, the languages are distinct from one another and do not have any mechanism to communicate.<\/p>\n
To remedy this, JSPyBridge<\/a> was created to allow Node.js and Python to interoperate. Language interoperation allows Node.js and Python to work together as if they are part of the same system and share data structures. With JSPyBridge, you can import and use Python API methods in Node.js as if they are native, and vice versa.<\/p>\n In this tutorial, we will use JSPyBridge to interoperate between Node.js and Python. In the first half, we will look at how to access and use Node.js functions, packages, classes, and arrays in Python. In the second half, we will look at how to use Python functions, modules, classes, and arrays in Node.js.<\/p>\n Jump ahead:<\/em><\/p>\n To get the most from this tutorial, you should have:<\/p>\n JSPyBridge is a bridge that allows Node.js and Python to interoperate. You can think of it as a literal bridge that sits between two programming languages, taking data or objects from one language and transforming them so that the language on the other side can parse them.<\/p>\n Some of the objects that can be shared between Python and Node.js are functions, classes, iterables, and callbacks. When using JSPyBridge, for example, you can import a function from Python into Node.js, invoke it, and access the return value in Node.js.<\/p>\n Here is a brief overview of JSPyBridge\u2019s features:<\/p>\n For more features, see the Bridge feature comparison<\/a> table.<\/p>\n In this section, we\u2019ll look at how we can access Node.js functions, packages, classes, and arrays in Python. To do this, we will create a project directory and download the First, create the project directory and change into the directory with the following command:<\/p>\n Since this is a Python directory, create a virtual environment for the project:<\/p>\n Activate the virtual environment:<\/p>\n With the virtual environment created, install the Now that we have our environment set up, we will begin interoperating Node.js with Python.<\/p>\n Let\u2019s create and call a JavaScript function in Python. The function will format an integer value into the currency of your choosing. You\u2019ll then import the JavaScript function in Python, pass arguments into it, and print the return value.<\/p>\n Open the In the preceding code block, we defined a Within the function, we create an The object has two properties: Upon creating the Now that the function has been defined, we will reference it in Python. Open and create the First, we import the Now, run the Upon running the file, you\u2019ll see output that looks like this:<\/p>\n This shows that Python called the JavaScript function, retrieved the return value, and logged it in the terminal.<\/p>\n Node.js has numerous packages that you can use in your projects, and JSPyBridge allows you to import and use them in Python. You don\u2019t even have to install them using npm \u2014 when you invoke the In this section, we will use the sqlstring<\/a> npm package in Python. The Open the First, we import the Now run the file and enter a name when the prompt shows up:<\/p>\n Running the file produces an output that looks like the following:<\/p>\n Notice in the output that when you first run the file, JSPyBridge downloaded the package. Once downloaded, the module was used to generate a SQL statement, which Python logged in the terminal.<\/p>\n In this section, we will import an ECMAScript 2015 (ES6) class, instantiate it, and then call the instance method in Python.<\/p>\n Create a new file named The To use the class in Python, we export it using Here, we import Save your file and run Running the file will yield the following output:<\/p>\n The output shows that the name first name and last name have been concatenated. This confirms that we can invoke and use JavaScript ES2015 classes in Python.<\/p>\n Let\u2019s create an array in Node.js, export it, and iterate over it in Python. We will build upon the Create the following file We create a Following this, we iterate over the Next, we will import the array in Python. Create the First, we reference the Now, run the file using the When you run the command, you will see an output that resembles the following:<\/p>\n The output confirms that we can iterate over a JavaScript array in Python.<\/p>\n So far, we looked at how to import functions, classes, and iterables from Node.js, and run them in Python within the same project directory. In this section, we will import a Node.js array that resides in another directory into Python and loop through each element.<\/p>\n First, move out of the project directory:<\/p>\n Next, create a new project directory and move into the directory:<\/p>\n Initialize the directory as an npm project:<\/p>\n Next, install the Next, create a new file, The file reuses a lot of code we had in the previous section; however, there are new changes. First, we import the UUID module. In the The With that, run the file using the You will see an output that looks like the following:<\/p>\n The output shows confirm that the objects are being created with the UUIDs.<\/p>\n Now, remove the Now that we know the program runs successfully, we will import the array into the main project directory, Return to the main project directory:<\/p>\n In the project directory, create a In the code block, we reference Now, run the Running the code yields the following:<\/p>\n As you can see in the output, we can successfully iterate over an array that is in another project directory.<\/p>\n Now that you know how to use JSPyBridge to access Node.js API in Python, we\u2019re going to access the Python API in the next section.<\/p>\n In this section, we will access Python modules, local Python files, functions, classes, and iterables in Node.js. To do this, we will create another directory that will contain our Node.js code, as well as the Python files.<\/p>\n First, move out of the current directory and go back to the home directory:<\/p>\n Now, in the home directory, create a new directory and change into it:<\/p>\n Since this is a Node.js directory, initialize Next, install the pythonia package<\/a>, which is a bridge for Node.js:<\/p>\n Next, add the With that, you are now set to use JSPyBridge in Node.js. Next, we will import a Python function and invoke it in Node.js.<\/p>\n In this section, we will create a function in Python, import it, and then run the function in Node.js. The function will make use of the Create a In the first line, import the Next, create the Import the In Node.js, JSPyBridge requires that every Python API call be prefixed with the Now, run the file with the When you run the command, you will see output that looks similar to this:<\/p>\n The output shows In this section, we will work with third-party Python modules in Node.js. Our program will use Matplotlib<\/a> and NumPy<\/a> to create a graph.<\/p>\n First, deactivate the current virtual environment:<\/p>\n Create a new virtual environment in the directory:<\/p>\n Activate the virtual environment:<\/p>\n Next, install the following modules with the following command:<\/p>\n To use the modules in JavaScript, create a First, we import the Next, we define arrays using the \n
\n
\n
Prerequisites<\/h3>\n
\n
What is JSPyBridge?<\/h2>\n
\n
Accessing JavaScript in Python<\/h2>\n
javascript<\/code> module<\/a>, which is a dependency of JSPyBridge.<\/p>\nmkdir python_demo && cd python_demo\n<\/pre>\n
python3 -m venv venv\n<\/pre>\n
source venv\/bin\/activate\n<\/pre>\n
javascript<\/code> module:<\/p>\npip3 install javascript\n<\/pre>\n
Importing a JavaScript function in Python<\/h3>\n
formatCurrency.js<\/code> file in your editor and add the following:<\/p>\nfunction formatCurrency(value, type) {\n format = new Intl.NumberFormat(\"en-US\", {\n style: \"currency\",\n currency: type,\n }).format;\n return format(value);\n}\nmodule.exports = { formatCurrency };\n<\/pre>\nformatCurrency()<\/code> function, which takes two arguments:<\/p>\n\n
value<\/code>, the amount of money<\/li>\ntype<\/code>, the currency we want the amount to be formatted to<\/li>\n<\/ol>\nIntl.NumberFormat<\/code> instance, which takes the language en-US<\/code> as the first argument, and an object containing formatting options as a second argument.<\/p>\nstyle<\/code> and currency<\/code>. The style<\/code> property accepts the formatting style, which is the currency<\/code> string here. The currency<\/code> property accepts the currency name in short form, which is stored in the type<\/code> variable.<\/p>\nIntl.NumberFormat<\/code> instance, a function is returned and stored in the format<\/code> variable. Next, you invoke the format()<\/code> function with the value<\/code> parameter as the argument. Once the format()<\/code> function runs, the formatCurrency()<\/code> function returns the result. Finally, we export the function formatCurrency()<\/code> so that it can be used in Python.<\/p>\nformat_currencies.py<\/code> file in your editor and add the following:<\/p>\nfrom javascript import require\n\ndata = require(\".\/formatCurrency.js\")\n\nvalue = 2000000\n\nprint(data.formatCurrency(value, \"USD\"))\nprint(data.formatCurrency(value, \"EUR\"))\n<\/pre>\n
require<\/code> method from the javascript<\/code> module. Next, we call the require()<\/code> method with the path to the JavaScript file formatCurrency.js<\/code>. After that, we define an integer and store it in the value<\/code> variable. In the last two lines, we call the formatCurrency()<\/code> with the value<\/code> variable and the currency we want.<\/p>\nformat_currency.py<\/code> file:<\/p>\npython3 format_currencies.py\n<\/pre>\n
$2,000,000.00\n\u20ac2,000,000.00\n<\/pre>\n
Importing and Using Node.js Packages in Python<\/h3>\n
require()<\/code> method with the package name, JSPyBridge will automatically fetch the package for you.<\/p>\nsqlstring<\/code> module can be used to escape and format SQL statements for MySQL.<\/p>\ngenerateSQL.py<\/code> file in your text editor:<\/p>\nfrom javascript import require\n\nsqlString = require(\"sqlstring\")\n\nname = input(\"What is your name?n\")\nsql = sqlString.format(\"SELECT * FROM customers WHERE name = ?\", [name])\n\nprint(sql)\n<\/pre>\n
require<\/code> method from the javascript<\/code> module. Second, we call the require()<\/code> method with the sqlstring<\/code> as the argument. Next, we call Python\u2019s input()<\/code> method to get user input, and after that, we invoke the format()<\/code> method of the sqlstring<\/code> module, which takes an SQL query as the argument. Finally, we print the formatted SQL query.<\/p>\npython3 generateSQL.py\n<\/pre>\n
Installing 'sqlstring' version 'latest'... This will only happen once.\n\nadded 1 package, and audited 2 packages in 502ms\n\nfound 0 vulnerabilities\n\n OK.\nWhat is your name?\njohn\n\nSELECT * FROM customers WHERE name = 'john'\n<\/pre>\n
Using ES2015 in Python<\/h3>\n
person.js<\/code>:<\/p>\nclass Person {\n constructor(firstName, lastName) {\n this.firstName = firstName;\n this.lastName = lastName;\n }\n\n getFullName() {\n return `${this.firstName} ${this.lastName}`;\n }\n}\n\nmodule.exports = { Person };\n<\/pre>\nPerson<\/code> class takes two arguments: firstName<\/code> and lastName<\/code>. It also has a getFullName()<\/code> method that concatenates the firstName<\/code> and the lastName<\/code> arguments to produce a full name.<\/p>\nmodule.exports<\/code>. Now, create another file create_person.py<\/code> file in your editor and add the following contents:<\/p>\nfrom javascript import require\n\ndata = require(\".\/person.js\")\nperson_one = data.Person.new(\"John\", \"Doe\")\nprint(person_one.getFullName())\n<\/pre>\n
require()<\/code> and reference the JavaScript file person.js<\/code>. Next, we create an instance of the class Person<\/code> by invoking the new()<\/code> method, which takes the first name and the last name as the arguments. Finally, we invoke the getFullName()<\/code> method of the Person<\/code> class and print the return value in the terminal.<\/p>\nperson.py<\/code>:<\/p>\npython3 create_person.py\n<\/pre>\n
John Doe\n<\/pre>\n
Using JavaScript iterables in Python<\/h3>\n
formatCurrency.js<\/code> program and make use of the formatCurrency()<\/code> function to format multiple values and append them to an array. The array will be exported and iterated in Python.<\/p>\nformatValues.js<\/code> with the following contents:<\/p>\nvalues = [200, 40000000, 2938, 80999];\nusd_values = [];\nfunction formatCurrency(value, type) {\n format = new Intl.NumberFormat(\"en-US\", {\n style: \"currency\",\n currency: type,\n }).format;\n return format(value);\n}\n\nfor (let i = 0; i < values.length; i++) {\n usd_values.push(formatCurrency(values[i], \"USD\"));\n}\n\nmodule.exports = { items: usd_values };\n<\/pre>\nvalues<\/code> array that contains numbers to be formatted as currency. Next, we define an empty array, usd_values<\/code> values, and the formatCurrency()<\/code> function that formats the given value in the currency of your choice.<\/p>\nvalues<\/code> array, and during each iteration, we call the formatCurrency()<\/code> function and push the formatted value into the usd_values<\/code> array. Once the loop finishes, we export an object that has an items<\/code> property, whose value is the usd_values<\/code> array.<\/p>\nlist_currencies.py<\/code> file with the following contents:<\/p>\nfrom javascript import require\n\ndata = require(\".\/formatValues.js\")\nfor item in data.items:\n print(item)\n<\/pre>\n
formatValues.js<\/code> file. Next, we iterate over the Node.js array and print the value during each iteration.<\/p>\npython3<\/code> command:<\/p>\npython3 list_currencies.py\n<\/pre>\n
$200.00\n$40,000,000.00\n$2,938.00\n$80,999.00\n<\/pre>\n
Importing a JavaScript file in Python from a different directory<\/h3>\n
cd ..\n<\/pre>\n
mkdir currency_app && cd currency_app\n<\/pre>\n
npm init -y\n<\/pre>\n
[uuid](https:\/\/www.npmjs.com\/package\/uuid)<\/code> package<\/a>, which generates a Universal Unique Identifier (UUID) that you can use to uniquely identify objects:<\/p>\nnpm install uuid\n<\/pre>\n
formatValues.js<\/code>, and add the following:<\/p>\nconst { v4: uuidv4 } = require(\"uuid\");\n\nvalues = [200, 40000000, 2938, 80999];\nusd_values = [];\nfunction formatCurrency(value, type) {\n format = new Intl.NumberFormat(\"en-US\", {\n style: \"currency\",\n currency: type,\n }).format;\n return format(value);\n}\n\nfor (let i = 0; i < values.length; i++) {\n usd_values.push({\n id: uuidv4(),\n currency: formatCurrency(values[i], \"USD\"),\n });\n}\n\nconsole.log(usd_values);\n\nmodule.exports = { items: usd_values };\n<\/pre>\nfor<\/code> loop, instead of pushing only the values, we create an object with the following properties: id<\/code> and currency<\/code>.<\/p>\nid<\/code> property is assigned a UUID, generated by calling the uuidv4()<\/code> function of the UUID module. The currency<\/code> property is assigned a value returned from calling the formatCurrency()<\/code> function. Finally, we have a console.log()<\/code> method that logs the usd_values<\/code> array in the console.<\/p>\nnode<\/code> command:<\/p>\nnode formatValues.js\n<\/pre>\n
[\n { id: 'bfdb0bd6-0e9a-4275-812f-dd1b81dde930', currency: '$200.00' },\n {\n id: '31b0d44a-8987-4f50-a683-99f4af477e6d',\n currency: '$40,000,000.00'\n },\n { id: 'ab9f0e76-875d-4e77-8bb9-61015b8a1a46', currency: '$2,938.00' },\n {\n id: 'f035883d-952a-4642-8c66-379858601f5f',\n currency: '$80,999.00'\n }\n]\n<\/pre>\nconsole.log()<\/code> method in the formatValues.js<\/code> file. We don\u2019t need it anymore, since the array contents will be displayed in Python.<\/p>\npython_demo<\/code>.<\/p>\ncd .. && cd python_demo\n<\/pre>\n
list_usd_values_with_uuid.py<\/code> file in your editor with the following:<\/p>\nfrom javascript import require\n\ndata = require(\".\/..\/currency_app\/formatValues.js\")\nfor item in data.items:\n print(f'ID: {item.id}')\n print(f'Amount in USD: {item.currency}')\n print(\"n\")\n<\/pre>\nformatCurrencies.js<\/code>, which resides in another directory. Next, we iterate over all elements in the array, and print the item UUID and the formatted currency in the console.<\/p>\nlist_usd_values_with_uuid.py<\/code> file:<\/p>\npython list_usd_values_with_uuid.py\n<\/pre>\n
ID: 35295372-eedc-44bd-8e19-360a990a1a44\nAmount in USD: $200.00\n\n\nID: c446ae79-3904-4c8b-8e74-31d4184612ca\nAmount in USD: $40,000,000.00\n\n\nID: 13ce5e1a-7f0a-4d81-bfd4-d18229a1b159\nAmount in USD: $2,938.00\n\n\nID: 755e1f39-3cad-4128-b806-4681acccd7d7\nAmount in USD: $80,999.00\n<\/pre>\n
Accessing Python in Node.js<\/h2>\n
cd ..\n<\/pre>\n
mkdir node_demo && cd node_demo\n<\/pre>\n
npm<\/code>:<\/p>\nnpm init -y\n<\/pre>\n
npm install pythonia\n<\/pre>\n
\"type\": \"module\"<\/code> line at the end of your package.json<\/code> to allow Node.js to use ES2015 modules:<\/p>\n{\n ...\n \"license\": \"ISC\",\n \"dependencies\": {\n \"pythonia\": \"^1.0.0\"\n },\n \"type\": \"module\"\n}\n<\/pre>\nImporting a Python function in Node.js<\/h3>\n
random<\/code> module<\/a> in Python.<\/p>\nrandom_choices.py<\/code> file and add the following:<\/p>\nimport random\n\n\ndef get_random_word():\n colors = [\"red\", \"green\", \"blue\", \"yellow\"]\n return random.choice(colors)\n<\/pre>\n
random<\/code> module from Python. We then define a function, get_random_word()<\/code>, which shuffles and returns a random value in the colors<\/code> array.<\/p>\npickRandomValue.js<\/code> file with the following code:<\/p>\nimport { python } from \"pythonia\";\nconst rand = await python(\".\/random_choices.py\");\nconsole.log(await rand.get_random_word());\npython.exit();\n<\/pre>\npython<\/code> function from the pythonia<\/code> package. Next, call the python()<\/code> function with the random_choices.py<\/code> path as the argument, which then starts a Python process.<\/p>\nawait<\/code> keyword. Following this, we call the get_random_word()<\/code> function and log the result into the terminal. Finally, we exit the process.<\/p>\nnode<\/code> command:<\/p>\nnode pickRandomValue.js\n<\/pre>\n
red\n<\/pre>\n
red<\/code>. Yours might show a different color because, after all, the package returns random values.<\/p>\nWorking with Python third-party modules in Node.js<\/h3>\n
deactivate\n<\/pre>\n
python3 -m venv venv\n<\/pre>\n
source venv\/bin\/activate\n<\/pre>\n
pip3 install numpy matplotlib\n<\/pre>\n
plot_graph.js<\/code> file and add the following:<\/p>\nimport { python } from 'pythonia'\nconst np = await python('numpy')\nconst plt = await python('matplotlib.pyplot')\n\n\nconst x = await np.array([1, 2, 3])\nconst y = await np.array([4, 1, 2])\n\nawait plt.plot(x, y)\n\nawait plt.title('matplotlib graph in Node.js')\n\nawait plt.savefig('graph.png')\npython.exit()\n<\/pre>\npython()<\/code> function from pythonia<\/code>. In the next two lines, we call the python<\/code> function to import NumPy and Matplotlib modules.<\/p>\nnp.array()<\/code> method, which are stored in the x<\/code> and y<\/code> variables. Following this, we invoke plt.plot()<\/code>, which takes the arrays in