Wolfram Client for Python

https://github.com/wolframresearch/wolframclientforpython
Admin
The Wolfram Client for Python allows Python developers to interact with the Wolfram Language and...
Tokens:15,809
Snippets:102
Trust Score:7.7
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Wolfram Client for Python from local source

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/install.rst

After cloning the repository or obtaining the library source, this command installs the library into your Python environment's site-packages directory. It requires navigating to the library's root directory first.

```shell
$ cd /path/to/library
$ pip install .
```

--------------------------------

### Install Wolfram Client Library

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Installs the Wolfram Client Library for Python using pip. This is the first step to integrating Wolfram Language capabilities into your Python projects.

```console
$ pip install wolframclient
```

--------------------------------

### Install Wolfram Client for Python using pip

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/install.rst

This command installs the latest stable version of the Wolfram Client for Python library from PyPI using the pip package manager. It is the recommended method for most users.

```shell
$ pip install wolframclient
```

--------------------------------

### Start Authenticated Wolfram Cloud Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Starts a new authenticated session with the Wolfram Cloud using the provided SecuredAuthenticationKey credentials. The 'authorized()' method checks if the session is successfully authenticated.

```Python
session = WolframCloudSession(credentials=sak)
session.start()
session.authorized()

```

--------------------------------

### Clone Wolfram Client for Python Git repository

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/install.rst

This command clones the public GitHub repository for the Wolfram Client for Python library. This method is suitable for developers who need the full source code.

```shell
$ git clone git://github.com/WolframResearch/WolframClientForPython
```

--------------------------------

### Python: Initialize Wolfram Language Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Shows the basic setup for establishing a connection to a local Wolfram Language kernel. This involves importing the necessary classes and creating a session instance.

```Python
>>> from wolframclient.evaluation import WolframLanguageSession
>>> from wolframclient.language import wlexpr
>>> session=WolframLanguageSession()
```

--------------------------------

### Pass Wolfram Language Options as Python Keyword Arguments

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Illustrates how Wolfram Language options are passed as Python keyword arguments (`**kwargs`). The example uses `ArrayPad` with the `Padding` option.

```Python
>>> session.evaluate(wl.ArrayPad([[0]], 1, Padding=1))
[[1, 1, 1], [1, 0, 1], [1, 1, 1]]
```

--------------------------------

### Initialize Wolfram Language Local Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Provides examples of initializing a `WolframLanguageSession` for local evaluation. It covers using the default path and specifying custom paths for the Wolfram Kernel executable on different operating systems.

```Python
from wolframclient.evaluation import WolframLanguageSession

# Create a session using the default path
session = WolframLanguageSession()

# Example for macOS
# session = WolframLanguageSession('/Applications/Wolfram Desktop.app/Contents/MacOS/WolframKernel')

# Example for Windows
# session = WolframLanguageSession('C:\\Program Files\\Wolfram Research\\Wolfram Desktop\\11.3\\WolframKernel.exe')

# Example for Linux
# session = WolframLanguageSession('/usr/local/Wolfram/Desktop/11.3/Executables/WolframKernel')
```

--------------------------------

### Manage Wolfram Language Session Lifecycle

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Explains the importance of terminating Wolfram Language sessions using `session.terminate()` or a `with` block. It also shows how to manually start a session and check its status.

```Python
>>> session = WolframLanguageSession()
>>> session.start()
>>> session.started
True
>>> session.terminate()
```

--------------------------------

### Evaluate Wolfram Language Expressions from Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates how to evaluate Wolfram Language expressions using the `evaluate` method of a `WolframLanguageSession`. Examples include string manipulation, mathematical operations, and querying Wolfram|Alpha.

```Python
from wolframclient.language import wl
from wolframclient.evaluation import WolframLanguageSession

session = WolframLanguageSession()

# Evaluate StringReverse
print(session.evaluate(wl.StringReverse('abc')))

# Evaluate MinMax on a list
print(session.evaluate(wl.MinMax([1, 5, -3, 9])))

# Query Wolfram|Alpha for Earth's distance from the Sun
distance = session.evaluate(wl.WolframAlpha("Earth distance from Sun", "Result"))
print(distance)

# Convert the distance unit to kilometers
d_km = session.evaluate(wl.UnitConvert(distance, "Kilometers"))
print(d_km)
```

--------------------------------

### Convert Wolfram Association to Python Dictionary

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how Wolfram Language associations are represented as Python dictionaries and vice versa. This example uses `AssociationMap` and `FromLetterNumber` to create an association and then evaluates it.

```Python
>>> session.evaluate(wl.AssociationMap(wl.FromLetterNumber, [1, 3, 5]))
{1: 'a', 3: 'c', 5: 'e'}
```

--------------------------------

### Maintain Session Persistence and Call Functions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Illustrates how expressions evaluated in a session are persistent. This example defines a function `f[x_] := x ^ 2` and then calls it within the same session.

```Python
>>> session.evaluate('f[x_] := x ^ 2')
Null
>>> session.evaluate('f[4]')
16
```

--------------------------------

### Evaluate Expressions in Parallel with Kernel Pool in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Illustrates the use of WolframEvaluatorPool to manage multiple Wolfram Language kernels for parallel computation. This is beneficial for CPU-intensive tasks where a single kernel's performance is limited. The example shows how to start a pool and dispatch work, with output indicating the number of kernels used.

```Python
from wolframclient.evaluation import WolframEvaluatorPool

# Start a pool of 4 evaluators
with WolframEvaluatorPool(max_num_kernels=4) as pool:
    # Dispatch work to the pool
    # ... (code to submit tasks to the pool) ...
    pass

# Example output indicating parallel execution
# Done after 3.04s, using up to 4 kernels.
```

--------------------------------

### Query Wolfram|Alpha

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Demonstrates how to directly query Wolfram|Alpha from Python to get specific information, such as the number of moons of Saturn. It uses `session.evaluate` with a Wolfram|Alpha query string.

```Python
>>> session.evaluate(wl.WolframAlpha("number of moons of Saturn", "Result"))
62
```

--------------------------------

### Python: Execute External Python Script for Asynchronous Evaluation

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

This snippet refers to an external Python file (`asynchronous1.py`) that demonstrates asynchronous evaluation. It highlights starting background tasks and observing their completion times.

```Python
import time
from wolframclient.evaluation import WolframLanguageSession

print("Starting an evaluation delayed by 2 seconds.")
session = WolframLanguageSession()

start_time = time.time()
future = session.evaluate_future('Pause[2]; 1+1')

print(f"After {time.time() - start_time:.4f}s, the code is running in the background, Python execution continues.")

result = future.result()
print(f"After {time.time() - start_time:.2f}s, result was available. Kernel evaluation returned: {result}")

session.stop()
```

--------------------------------

### Manage Session Lifecycle with 'with' Block

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Delegates the lifecycle management of a Wolfram Language session using a 'with' block, ensuring proper session handling. This example demonstrates evaluating a Wolfram Language expression within the managed session.

```Python
>>> with WolframLanguageSession() as wl_session:
...     wl_session.evaluate(wl.StringReverse('abc'))
...
```

--------------------------------

### Export Wolfram Language Expression to File

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to export a Wolfram Language expression directly to a file using the `stream` parameter in the `export` function. This example exports a `ListPlot` of prime numbers to a WXF file.

```Python
from wolframclient.serializers import export
from wolframclient.language import wl

wl_expr = wl.ListPlot(wl.Prime(wl.Range(25)))
export(wl_expr, stream='/path/to/file.wxf', target_format='wxf')
```

--------------------------------

### Defining and Evaluating Custom Wolfram Functions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Provides a practical example of defining a custom Wolfram Language function (`max`) within a Python session and then evaluating it with a list of strings. It highlights the difference between using `wlexpr` for InputForm evaluation and direct object serialization.

```Python
from wolframclient.evaluation import WolframLanguageSession
from wolframclient.language import wl, Global, wlexpr

session = WolframLanguageSession()

# Define the 'max' function using InputForm string
session.evaluate(wlexpr('max[s : List[__String]] := MaximalBy[s, StringLength]'))

# Evaluate the custom function using Global.max
print(session.evaluate(Global.max(['hello', 'darkness', 'my', 'old', 'friend'])))

# Attempting to evaluate wl.max (System`max) results in an unevaluated expression
print(session.evaluate(wl.max(['hello', 'darkness', 'my', 'old', 'friend'])))
```

--------------------------------

### Create Python Function from Wolfram Language Definition

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates creating a Python function from a Wolfram Language function using `session.function`. This allows calling Wolfram Language functions directly from Python. It shows examples using `StringReverse` and a custom `distance` function.

```Python
>>> str_reverse = session.function(wl.StringReverse)
>>> str_reverse('abc')
'cba'
```

```Wolfram Language
distance[country1_String, country2_String] := QuantityMagnitude[
    GeoDistance[
        EntityValue[Entity["Country", country1], "CapitalCity"],
        EntityValue[Entity["Country", country2], "CapitalCity"]
    ],
    "Kilometers"
];
```

```Python
>>> session.evaluate(wlexpr('''
    distance[country1_String, country2_String] := QuantityMagnitude[
        GeoDistance[
            EntityValue[Entity["Country", country1], "CapitalCity"],
            EntityValue[Entity["Country", country2], "CapitalCity"]
        ],
        "Kilometers"
    ];
'''))
```

```Python
>>> capital_distance = session.function(wlexpr('distance'))
>>> capital_distance('France', 'Japan')
9740.93438174525
>>> capital_distance('Canada', 'USA')
721.9965597052519
```

```Python
>>> from wolframclient.language import Global
>>> capital_distance = session.function(Global.distance)
```

--------------------------------

### Get Quantity Magnitude as Python Number

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates how to retrieve the magnitude of a Wolfram Language Quantity as a Python number using `QuantityMagnitude`. This is useful for numerical computations in Python.

```Python
>>> session.evaluate(wl.QuantityMagnitude(d_km))
150801534.3173264
```

--------------------------------

### Python: Compute integer Eigenvalues using Wolfram Client Library

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Shows how to compute integer eigenvalues of a Python matrix using the Wolfram Client Library's access to Wolfram Language algebra functions. This example demonstrates a direct call to the Eigenvalues function.

```python
from wolframclient.evaluation import WolframLanguageSession
from wolframclient.language import wl, WolframAPIDefaults

matrix = [[1, 2], [3, 4]]

with WolframLanguageSession() as session:
    result = session.evaluate(wl.Eigenvalues(matrix))
    print(result)

```

--------------------------------

### Run Coroutines Concurrently in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates how to run two independent coroutines concurrently using the Wolfram Client for Python. This allows for parallel execution of tasks, improving performance when operations can be done independently. The example shows the output after both evaluations have finished.

```Python
from wolframclient.evaluation import WolframLanguageSession
from wolframclient.language import wl, Wolfram

import asyncio

async def evaluate_expressions():
    async with WolframLanguageSession() as session:
        # Evaluate two expressions concurrently
        expr1 = session.evaluate(wl.Pause(2.04) or wl.Evaluate(wl.Table(wl.RandomInteger(), [1000])))
        expr2 = session.evaluate(wl.Pause(2.04) or wl.Evaluate(wl.Table(wl.RandomInteger(), [1000])))

        results = await asyncio.gather(expr1, expr2)
        print(f"After 2.04s, both evaluations finished returning: {results}")

if __name__ == "__main__":
    asyncio.run(evaluate_expressions())
```

--------------------------------

### Parallel Evaluation of Multiple Expressions in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates the `parallel_evaluate` function for evaluating numerous expressions concurrently. This function automatically manages a kernel pool, computes expressions from an iterable, and then terminates the pool. The example shows evaluating ten 'Pause[1]; $ProcessID' expressions.

```Python
from wolframclient.evaluation import parallel_evaluate

# Build a list of ten delayed $ProcessID expressions
expressions = ['Pause[1]; $ProcessID' for _ in range(10)]

# Evaluate in parallel and get back a list of PIDs
results = parallel_evaluate(expressions)
print(results)
```

--------------------------------

### Set up Wolfram Language Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Establishes a session with the Wolfram Language, enabling communication between Python and the Wolfram Engine. This requires importing necessary classes from the wolframclient library.

```python
from wolframclient.evaluation import WolframLanguageSession
from wolframclient.language import wl, wlexpr
session = WolframLanguageSession()
```

--------------------------------

### Initialize SecuredAuthenticationKey in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Initializes an instance of SecuredAuthenticationKey in Python using the consumer key and secret strings obtained from the Wolfram Cloud.

```Python
from wolframclient.evaluation import SecuredAuthenticationKey, WolframCloudSession

sak = SecuredAuthenticationKey(
    'T2ghIEhpISDinIw=',
    'VGhhdCdzIE1ZIHNlY3JldCE=')

```

--------------------------------

### Using System Context Symbols

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Shows how to explicitly represent symbols from the Wolfram Language's 'System' context using the `System` factory. This is necessary when you need to refer to built-in functions with absolute clarity, especially when serialization to WXF format is involved.

```Python
from wolframclient.language import System

# Representing the built-in 'Classify' function
print(System.Classify)
```

--------------------------------

### Import WXF File as Python Object

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Opens a WXF file in binary read mode and deserializes its content into a Python dictionary. This demonstrates the process of retrieving previously exported data.

```Python
with open('/path/to/file.wxf', 'rb') as fp:
    binary_deserialize(fp)

{'name': 'Alice', 'age': 37}
```

--------------------------------

### Export to WXF with Compression

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Illustrates exporting a Python list to WXF format with zlib compression enabled. The output is a compressed byte string.

```Python
>>> export([1, 2, 3], target_format = "wxf", compress = True)
'8C:x\x9cKc.f\xf1\xc9,.qftfrf\x06\x00\x1b\xf8\x03L'
```

--------------------------------

### Create and Export a Bar Chart

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to create a `BarChart` from Python data and export it as a PNG image using `Export`. It also demonstrates evaluating the export expression and loading the image.

```Python
>>> data = [.3, 2, 4, 5, 5.5]
>>> graphic = wl.BarChart(data)
>>> path = "/tmp/data.png"
>>> png_export = wl.Export(path, graphic, "PNG")
>>> session.evaluate(png_export)
'/tmp/data.png'
```

```Python
>>> from PIL import Image
>>> img = Image.open('/tmp/data.png')
>>> session.evaluate(wl.ImageDimensions(img))
[360, 219]
```

--------------------------------

### Deploy API for Image Dimensions with JSON Output

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Deploys an APIFunction that accepts an image, returns its dimensions, and formats the output as JSON. This is useful for interoperability with other systems.

```Wolfram Language
CloudDeploy[
    APIFunction[{"image" -> "Image"},
        ImageDimensions[#image] &,
        "JSON"
    ],
    CloudObject["api/private/imagedimensions"]
]
```

--------------------------------

### Build Wolfram Language Code in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Illustrates building Wolfram Language code programmatically within Python. This allows for dynamic generation of Wolfram Language expressions, such as mapping a squaring function over a range.

```python
func_squared = wlexpr('#^2 &')
session.evaluate(wl.Map(func_squared, wl.Range(5)))
```

--------------------------------

### Use WolframAPICall for API Interaction

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Illustrates using the WolframAPICall class for a more structured way to interact with Wolfram Language APIs. It covers setting parameters and performing the call.

```Python
from wolframclient.evaluation import WolframAPICall
call = WolframAPICall(session, ('MyWolframID', 'api/private/xsquared'))
call.set_parameter('x', 4)
result = call.perform()
print(result.get())
```

--------------------------------

### Import WXF File in Wolfram Desktop

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Provides the Wolfram Language code snippet to import a WXF file that was previously exported from Python. This allows visualization and further processing within Wolfram Desktop.

```Wolfram Language
Import["/path/to/file.wxf"]
```

--------------------------------

### Representing Symbols in Arbitrary Contexts

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates how to construct Wolfram Language symbols with arbitrary contexts and subcontexts using the `wl` factory. This provides flexibility in managing namespaces for complex projects.

```Python
from wolframclient.language import wl

# Representing symbols in nested contexts
print(wl.Developer.PackedArrayQ)
print(wl.MyContext.MySubContext.myFunction)
```

--------------------------------

### Serialize to WXF Binary Format

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates serializing a Wolfram Language expression to the efficient binary WXF format using the `target_format='wxf'` argument in the `export` function. WXF is optimized for data exchange.

```Python
from wolframclient.serializers import export
from wolframclient.language import wl

export(wl.Select([1,2,3], wl.PrimeQ), target_format='wxf')
```

--------------------------------

### Create Pandas DataFrame

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Demonstrates creating a Pandas DataFrame in Python. This is a prerequisite for applying Wolfram Language functions to data structures commonly used in data analysis.

```python
import pandas
df = pandas.DataFrame({'A': [1, 2], 'B': [11, 12]}, index=['id1', 'id2'])
df
```

--------------------------------

### Export Fraction to Wolfram Language Rational

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Demonstrates exporting a Python `fractions.Fraction` object to a Wolfram Language `Rational` number.

```Python
>>> import fractions
>>> export(fractions.Fraction(2, 3))
'(2 / 3)'
```

--------------------------------

### Call Wolfram Language Functions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Shows how to call Wolfram Language's built-in functions, such as `MinMax`, directly from Python. The `wl` object provides convenient access to these functions.

```python
session.evaluate(wl.MinMax([1, -3, 0, 9, 5]))
```

--------------------------------

### Represent Wolfram Language Symbols and Functions in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates how to construct Python objects that represent Wolfram Language symbols and functions using the `wolframclient.language.wl` factory. This is a fundamental step for interacting with the Wolfram Language from Python.

```Python
from wolframclient.language import wl

# Represent the Wolfram Language symbol Now
print(wl.Now)

# Represent Wolfram Language functions like Select and PrimeQ
print(wl.Select(wl.PrimeQ, wl.Range(5)))

# Represent functions with options using named parameters
print(wl.ArrayPad([[0]], 1, Padding=1))
```

--------------------------------

### Represent Wolfram Language Pure Functions with wlexpr

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to use the `wolframclient.language.wlexpr` function to represent Wolfram Language pure functions, which are often defined using the `#` notation. This allows for dynamic construction of Wolfram Language code.

```Python
from wolframclient.language import wlexpr

# Represent a Wolfram Language pure function
print(wlexpr('#^2 &'))
```

--------------------------------

### Create and Deploy APIFunction for Squaring

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Defines an APIFunction in Wolfram Language that takes an integer and returns its square. It is then deployed as a cloud object and permissions are set for access.

```Wolfram Language
api = APIFunction[{"x" -> "Integer"},
    #x^2 &
    ]
CloudDeploy[api, CloudObject["api/private/xsquared"]]
SetPermissions[
    CloudObject["api/private/xsquared"],
    SecuredAuthenticationKeys["pythonclientlibrary"] -> {"Read", "Execute"}
]
```

--------------------------------

### Represent Wolfram Language Expressions as Python Objects

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Illustrates how Wolfram Language expressions, like `Quantity`, can be represented as native Python objects using the library, facilitating easier manipulation and understanding within Python.

```python
wl.Quantity(12, "Hours")
```

--------------------------------

### Export to Wolfram Language WXF Format

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Shows how to export a Python list to Wolfram Language's WXF format, an efficient binary representation. The output is a byte string representing the serialized data.

```Python
>>> export([1, 2, 3], target_format = "wxf")
'8:f\x03s\x04ListC\x01C\x02C\x03'
```

--------------------------------

### Evaluate Wolfram Language Expression in Cloud

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Evaluates a Wolfram Language expression on the Wolfram Public Cloud using an authenticated session. This demonstrates a one-shot evaluation, where each evaluation is independent.

```Python
from wolframclient.language import wl

session.evaluate(wl.Range(3))

session.evaluate(wl.StringReverse('abc'))

```

--------------------------------

### Call Wolfram Language API from Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates how to call a deployed Wolfram Language API from Python. It shows how to specify the API, pass parameters, and retrieve the result, including parsing it as an integer.

```Python
api = ('MyWolframID', 'api/private/xsquared')
result = session.call(api, {'x' : 4})
print(result.success)
print(int(result.get()))
```

--------------------------------

### Configure Python Logging for Wolfram Client

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Shows how to configure the standard Python `logging` module to capture messages from the Wolfram Client library. This involves setting up a basic logging configuration to direct messages to standard output, allowing visibility into the client's operations.

```Python
import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(levelname)s:%(name)s:%(message)s'
)

# Example output demonstrating log messages:
# INFO:wolframclient.evaluation.kernel.kernelcontroller:Kernel writes commands to socket: <Socket: uri=tcp://127.0.0.1:61335>
# INFO:wolframclient.evaluation.kernel.kernelcontroller:Kernel receives evaluated expressions from socket: <Socket: tcp://127.0.0.1:61336>
# INFO:wolframclient.evaluation.kernel.kernelcontroller:Kernel process started with PID: 54259
# INFO:wolframclient.evaluation.kernel.kernelcontroller:Kernel 54259 is ready. Startup took 1.74 seconds.
```

--------------------------------

### Connect to Wolfram Cloud (Wolfram Language)

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Connects to the Wolfram Cloud using Wolfram ID and password. This is a prerequisite for deploying APIs or performing other authenticated operations directly from Wolfram Language.

```Wolfram Language
CloudConnect("MyWolframID", "myPassword")

```

--------------------------------

### Define and Evaluate Wolfram Language Function in Cloud

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Defines a simple Wolfram Language function 'f[x_]:=x+1' in the cloud and attempts to evaluate it. Note that due to the one-shot nature of evaluations, the function definition is not persistent across calls.

```Python
from wolframclient.language import wlexpr

result = session.evaluate(wlexpr('f[x_]:=x+1'))

result = session.evaluate(wlexpr('f[1]'))

```

--------------------------------

### Retrieve Authentication Key and Secret (Wolfram Language)

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Retrieves the 'ConsumerKey' and 'ConsumerSecret' strings from a generated secured authentication key. These credentials are required for authenticating with the Wolfram Cloud.

```Wolfram Language
sak["ConsumerKey"]      (* "T2ghIEhpISDinIw=" *)
sak["ConsumerSecret"]   (* "VGhhdCdzIE1ZIHNlY3JldCE=" *)
```

--------------------------------

### Define Native Python Functions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Explains how to define Python functions that wrap Wolfram Language functions, such as `StringReverse`. This allows for reusable and Pythonic integration of Wolfram capabilities.

```python
str_reverse = session.function(wl.StringReverse)
str_reverse('abc')
```

--------------------------------

### Export to Wolfram Language InputForm

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Demonstrates exporting a Python list to Wolfram Language's InputForm, which is the default and most readable format. The output is a string representation of the Wolfram Language list.

```Python
>>> export([1, 2, 3], target_format = "wl")
'{1, 2, 3}'
```

--------------------------------

### Combine wl and wlexpr for Complex Expressions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Illustrates how to combine the `wl` factory and `wlexpr` function to construct more complex Wolfram Language expressions, such as applying a pure function to a list using `Map`.

```Python
from wolframclient.language import wl, wlexpr

# Combine wl.Map with wlexpr for a pure function
print(wl.Map(wlexpr('#^2&'), [1,2,3]))
```

--------------------------------

### Generate Secured Authentication Key (Wolfram Language)

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Generates a secured authentication key for authenticating with the Wolfram Cloud. This key is associated with a Wolfram account and is used to establish secure connections.

```Wolfram Language
sak = GenerateSecuredAuthenticationKey["pythonclientlibrary"]
```

--------------------------------

### Representing Wolfram Language Expressions in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates how to use the `wl` factory from `wolframclient.language` to represent Wolfram Language expressions in Python. This allows for programmatic construction of expressions that can be evaluated by a Wolfram Language kernel.

```Python
from wolframclient.language import wl

# Representing a Wolfram Language function call
print(wl.Range(3))
```

--------------------------------

### Call Image Dimension API with File Parameter

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to call an API that processes an image file. It involves creating a WolframAPICall, adding the image file as a parameter, and parsing the JSON response.

```Python
import json
api = ('MyWolframID', 'api/private/imagedimensions')
api_call = WolframAPICall(session, api)
with open('/path/to/example/image.png', 'rb') as fp:
    api_call.add_file_parameter('image', fp)
    result = api_call.perform()
print(json.loads(result.get()))
```

--------------------------------

### Export OrderedDict to Wolfram Language Association

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Demonstrates exporting a Python `OrderedDict` to a Wolfram Language association, preserving the order of key-value pairs.

```Python
>>> from collections import OrderedDict
>>> export(OrderedDict([(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]))
'<|0 -> \"a\", 1 -> \"b\", 2 -> \"c\", 3 -> \"d\"|>' 
```

--------------------------------

### Create Wolfram Language Quantity in Python

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates how to create a Wolfram Language Quantity object using the `wolframclient.language.wl` module in Python. This object can then be serialized.

```Python
from wolframclient.language import wl

wl.Quantity(12, "Hours")
```

--------------------------------

### Deserialize WXF Binary Input

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to deserialize Wolfram Language WXF binary data back into Python objects using the `binary_deserialize` function. This enables bidirectional data exchange.

```Python
from wolframclient.serializers import export
from wolframclient.deserializers import binary_deserialize

my_list = [1,2,3]
wxf = export(my_list, target_format='wxf')

# Assuming wxf contains the binary data
# python_object = binary_deserialize(wxf)
```

--------------------------------

### Evaluate Wolfram Language Code

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Demonstrates how to evaluate arbitrary Wolfram Language expressions directly from Python using the established session. The `wlexpr` function is used to parse Wolfram Language code strings.

```python
session.evaluate(wlexpr('Range[5]'))
```

--------------------------------

### Evaluate Wolfram Language Code Using InputForm Strings

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates using `wlexpr` to evaluate Wolfram Language code provided as strings. This is particularly useful for defining pure functions or complex expressions.

```Python
>>> from wolframclient.language import wlexpr
>>> session.evaluate(wlexpr('Map[#^2 &, Range[5]]'))
[1, 4, 9, 16, 25]
```

```Python
>>> session.evaluate(wl.Map(wlexpr('#^2&'), wl.Range(5)))
```

--------------------------------

### Serialize Python List to Wolfram Language InputForm

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates serializing a Python list of integers into a Wolfram Language InputForm string representation using the `export` function.

```Python
from wolframclient.serializers import export
print(export([1,2,3]))
```

--------------------------------

### Apply Wolfram Language to DataFrame

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Shows how to apply Wolfram Language functions, like `Total`, directly to a Pandas DataFrame. The library handles the conversion and execution seamlessly.

```python
session.evaluate(wl.Total(df))
```

--------------------------------

### Evaluate Wolfram Language Expression

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Shows how to evaluate a Wolfram Language expression that calculates the limit of a function. It first defines the limit expression using `wlexpr` and then uses the `session.evaluate` method to compute the result.

```Python
>>> limit = wlexpr('Limit[x Log[x^2], x -> 0]')
>>> session.evaluate(limit)
0
```

--------------------------------

### Python: Custom WXFConsumer for symbolic eigenvalues and Wolfram Language symbols

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates creating a WXFConsumer to convert Wolfram Language symbols like Plus, Times, Pi, Rational, and Complex into their corresponding Python objects (math.pi, fractions.Fraction, complex). This provides a detailed look at the extension mechanism for handling symbolic computations.

```python
from wolframclient.deserializers import WXFConsumer
from wolframclient.language import wl
import math
from fractions import Fraction

class SymbolicEigenvalueConsumer(WXFConsumer):
    def build_symbol(self, context, symbol):
        if symbol == wl.Pi:
            return math.pi
        elif symbol == wl.E:
            return math.e
        return super().build_symbol(context, symbol)

    def build_function(self, context, element):
        if element.head == wl.Plus:
            return sum(self.process(arg) for arg in element.args)
        elif element.head == wl.Times:
            product = 1
            for arg in element.args:
                product *= self.process(arg)
            return product
        elif element.head == wl.Rational:
            return Fraction(element.args[0], element.args[1])
        elif element.head == wl.Complex:
            return complex(self.process(element.args[0]), self.process(element.args[1]))
        return super().build_function(context, element)

```

--------------------------------

### Export Dictionary to WXF Format

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Exports a Python dictionary to a file in the WXF format. This function allows for data persistence and exchange with Wolfram Language.

```Python
export({'name' : 'Alice', 'age' : 37}, target_format='wxf', stream='/path/to/file.wxf')
'/path/to/file.wxf'
```

--------------------------------

### Export Python Generator to Wolfram Language List

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Shows how a Python generator is serialized as a Wolfram Language List. This is useful for handling large datasets to avoid memory issues.

```Python
>>> def gen():
...     yield 1
...     yield 2
... 
>>> export(gen())
'{1, 2}'
```

--------------------------------

### Import binary_deserialize Function

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Imports the necessary binary_deserialize function from the wolframclient.deserializers module. This function is used for deserializing data.

```Python
from wolframclient.deserializers import binary_deserialize
```

--------------------------------

### Terminate Wolfram Client Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Provides the code to properly terminate the Wolfram Client session and release all associated resources. This is a crucial step for cleanup after using the library.

```Python
>>> session.terminate()
```

--------------------------------

### Create Cloud Function from Built-in Symbol

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Creates a reusable cloud function from a built-in Wolfram Language symbol, in this case, 'StringReverse'. The function can then be applied to arguments within the cloud session.

```Python
wl_str_reverse = session.function(wl.StringReverse)

wl_str_reverse("hello")

wl_str_reverse("world.")

```

--------------------------------

### Export Special Numeric Values to Wolfram Language

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Shows how Python's infinity and NaN values are serialized to Wolfram Language's `DirectedInfinity` and `Indeterminate`.

```Python
>>> export({'+inf': float('inf'), '-inf': - float('inf'), 'nan': float('NaN')})
'<|\"+\inf\" -> DirectedInfinity[1], \"-\inf\" -> DirectedInfinity[-1], \"nan\" -> Indeterminate|>' 
```

--------------------------------

### Serialize Nested Wolfram Language Expressions

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Illustrates serializing nested Wolfram Language expressions, including mixing Python types with Wolfram Language functions like `Select` and `PrimeQ`. The `export` function handles the conversion.

```Python
from wolframclient.serializers import export
from wolframclient.language import wl

export(wl.Select([1,2,3], wl.PrimeQ))
```

--------------------------------

### Access Wolfram Knowledgebase for GeoNearest

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Illustrates how to query the Wolfram Knowledgebase to find the nearest ocean to the current location. It uses `wlexpr` to define the Wolfram Language query and `session.evaluate` to retrieve the result.

```Python
>>> ocean = wlexpr('GeoNearest[Entity["Ocean"], Here]')
>>> session.evaluate(ocean)
[Entity['Ocean', 'AtlanticOcean']]
```

--------------------------------

### Using Global Context Symbols

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Illustrates how to represent user-defined symbols that reside in the 'Global' context using the `Global` factory. This is the default context for user-defined functions and variables in Wolfram Language.

```Python
from wolframclient.language import Global

# Representing a user-defined symbol 'f'
print(Global.f)
```

--------------------------------

### Export Python Dictionary to Wolfram Language

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Demonstrates exporting a Python dictionary containing various data types (list, set, frozenset, dict) to Wolfram Language. The output shows the corresponding Wolfram Language association.

```Python
>>> export({"list": [1, 2, 3], "set": set([1, 2, 2, 4]), "frozenset": frozenset([1, 2, 2, 4]), "dict": dict(a = 2)})
'<|\"list\" -> {1, 2, 3}, \"set\" -> {1, 2, 4}, \"frozenset\" -> {1, 2, 4}, \"dict\" -> <|\"a\" -> 2|>|>' 
```

--------------------------------

### Export Timedelta to Wolfram Language Quantity

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Illustrates exporting a Python `datetime.timedelta` object to a Wolfram Language `Quantity`.

```Python
>>> import datetime
>>> export(datetime.timedelta(seconds = 340))
```

--------------------------------

### Define Wolfram Language Expression

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/index.rst

Demonstrates how to define a Wolfram Language expression, such as a function definition, using the `wlexpr` function within the Wolfram Client Library for Python. This allows for the creation and manipulation of symbolic expressions.

```Python
>>> wlexpr('f[x_] := x^2')
(f[x_] := x^2)
```

--------------------------------

### Python: Terminate Wolfram Language Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates how to properly stop and terminate an active Wolfram Language session to free up resources. This is a crucial step after completing all evaluations.

```Python
>>> session.stop()
```

--------------------------------

### Python Serialization with Custom Normalizer

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Demonstrates how to serialize a custom Python class by defining a normalizer function. The normalizer converts instances of `MyPythonClass` into Wolfram Language expressions before serialization.

```Python
from wolframclient.language import wl
from wolframclient.serializers import export

class MyPythonClass(object):
    def __init__(self, *arguments):
        self.arguments = arguments

def normalizer(o):
    if isinstance(o, MyPythonClass):
        return wl.MyWolframFunction(*o.arguments)
    return o

# Example usage:
# export(MyPythonClass(1,2), normalizer=normalizer)
```

--------------------------------

### Enable Kernel Logging in Wolfram Language

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Explains how to enable logging from within the Wolfram Language kernel when interacting with the Wolfram Client for Python. This is achieved by setting the `kernel_loglevel` parameter during the initialization of `WolframLanguageSession`.

```Python
from wolframclient.evaluation import WolframLanguageSession
import logging

# Initialize session with kernel logging enabled (e.g., at INFO level)
with WolframLanguageSession(kernel_loglevel=logging.INFO) as session:
    # ... (perform evaluations) ...
    pass

# Note: If kernel_loglevel is NOTSET (default), kernel logging is disabled.
```

--------------------------------

### Deserialize Bytes to Python Object

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Deserializes a byte string (wxf) into a Python object. This is a core function for converting Wolfram data into a usable Python format.

```Python
binary_deserialize(wxf)
[1, 2, 3]
```

--------------------------------

### Export Numeric Types to Wolfram Language

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/public_api.rst

Illustrates the serialization of various Python numeric types (int, float, Decimal, complex) to their Wolfram Language counterparts.

```Python
>>> import decimal
>>> export({'int': 1, 'float':2.3, 'decimal': decimal.Decimal(1), 'complex': complex(3, 4)})
'<|\"int\" -> 1, \"float\" -> 2.300000, \"decimal\" -> 1, \"complex\" -> Complex[3.000000, 4.000000]|>'
```

--------------------------------

### Serialize Pandas Series to List of Rules

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Shows how to explicitly serialize a Pandas Series to a Wolfram Language list of rules by setting `pandas_series_head='list'` in the `export` function.

```Python
import pandas
from wolframclient.serializers import export

series = pandas.Series([1, 2, 3], index=[-1, 'a', 1])
export(series, pandas_series_head='list')
```

--------------------------------

### Serialize Pandas Series to Wolfram Language

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/basic_usages.rst

Demonstrates serializing a Pandas Series to Wolfram Language. The output format depends on the index type and can be controlled using `pandas_series_head`.

```Python
import pandas
from wolframclient.serializers import export

series = pandas.Series([1, 2, 3], index=[-1, 'a', 1])
export(series)
```

--------------------------------

### Python: Execute External Python Script for Asyncio Evaluation

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

This snippet refers to an external Python file (`asynchronous2.py`) that showcases the use of `asyncio` with Wolfram Language sessions. It defines and runs coroutines for delayed evaluations.

```Python
import asyncio
import time
from wolframclient.evaluation import WolframLanguageAsyncSession

async def delayed_evaluation(session, expr):
    print(f"Starting evaluation of: {expr}")
    start_time = time.time()
    result = await session.evaluate(expr)
    end_time = time.time()
    print(f"Evaluation finished in {end_time - start_time:.2f}s. Result: {result}")
    return result

async def main():
    session = WolframLanguageAsyncSession()
    
    # Evaluate first expression
    await delayed_evaluation(session, 'Pause[1]; 1*2')
    
    # Evaluate second expression after a delay
    await delayed_evaluation(session, 'Pause[1]; 3*4')
    
    await session.stop()

if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Python: Evaluate Wolfram Language Expression (Synchronous)

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Illustrates how to evaluate a Wolfram Language expression synchronously using the Wolfram Client for Python. This method blocks until the evaluation is complete.

```Python
>>> session.evaluate(wlexpr('NIntegrate[Sqrt[x^2 + y^2 + z^2], {x, 0, 1}, {y, 0, 1}, {z, 0, 1}]'))
```

--------------------------------

### Python: Terminate Wolfram Language Session

Source: https://github.com/wolframresearch/wolframclientforpython/blob/master/docs/docpages/advanced_usages.rst

Demonstrates the correct way to terminate a Wolfram Language session, releasing the kernel resources. This should be called when the session is no longer needed.

```Python
>>> session.terminate()
```
Tokens:
Raw