Spotfire Python

https://github.com/spotfiresoftware/spotfire-python
Admin
Spotfire Python is a library that provides functions for integrating Python with Spotfire, including...
Tokens:24,404
Snippets:314
Trust Score:6.3
License:BSD-3-Clause
Update:2 months ago
Show doc for...
Tokens:
Raw
### Troubleshooting Commands

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Common commands for resolving installation and file path issues.

```bash
pip install spotfire
```

```python
os.path.exists()
```

```python
set_spotfire_types()
```

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

### Install Spotfire Python Package

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/README.md

Use pip to install the core package. Optional extras can be specified for additional functionality like plotting or geographic data support.

```sh
pip install spotfire
```

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

### Install optional spotfire features

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Use these commands to install specific optional dependencies for geographic data or plotting support.

```bash
# Install with all optional features
pip install spotfire[geo,plot]

# Install with specific plotting backend
pip install spotfire[plot-matplotlib]
```

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

### Usage example for _SpkVersion

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Demonstrates parsing, incrementing, and extracting version information.

```python
from spotfire.spk import _SpkVersion

# Parse version from string
v = _SpkVersion.from_str("1.2.3.4")
print(v)  # 1.2.3.4

# Increment versions
v.increment_major()
print(v)  # 2.0.0.0

# From Python version
v = _SpkVersion.from_version_info(0)
# Returns Python version encoded as SPK version
```

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

### Set package versioning

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Example command for specifying the package version during creation.

```bash
python -m spotfire.spk python \
    --name "Python" \
    --id "550e8400-e29b-41d4-a716-446655440000" \
    --version "1.0.0" \
    --output "python.spk"
```

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

### Example: Build Python Interpreter SPK with Dependencies

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Creates a requirements file and builds an SPK package including specific machine learning libraries.

```bash
# Create requirements file
cat > requirements.txt << EOF
numpy>=1.23.5
pandas>=2.2.2
scikit-learn>=1.3.0
EOF

# Build SPK with dependencies
python -m spotfire.spk python \
    --name "Python with ML" \
    --id "550e8400-e29b-41d4-a716-446655440000" \
    --version "1.0.0" \
    --output "python_ml.spk" \
    --requirements requirements.txt \
    --brand '{"author":"Data Science Team", "contact":"datascience@company.com"}'
```

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

### Example: Build Third-Party Packages SPK

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Creates a requirements file and builds an SPK containing only the specified third-party packages.

```bash
# Create requirements file for domain-specific packages
cat > ml_requirements.txt << EOF
xgboost>=2.0.0
lightgbm>=4.0.0
optuna>=3.0.0
EOF

# Build packages-only SPK
python -m spotfire.spk packages \
    --name "ML Libraries" \
    --id "6ba7b810-9dad-11d1-80b4-00c04fd430c8" \
    --version "1.0.0" \
    --output "ml_libs.spk" \
    --requirements ml_requirements.txt
```

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

### Handle SBDFWarning

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/errors.md

Example of capturing and printing warnings issued during type configuration.

```python
import warnings
import pandas as pd
from spotfire.public import set_spotfire_types

df = pd.DataFrame({'col1': [1, 2, 3]})

with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    
    # This generates two warnings
    set_spotfire_types(df, {
        'nonexistent': 'Integer',  # Column doesn't exist
        'col1': 'InvalidType'       # Type not recognized
    })
    
    for warning in w:
        if issubclass(warning.category, Warning):
            print(f"Warning: {warning.message}")
```

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

### Execute Data Function Example

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Demonstrates creating, configuring, and evaluating an AnalyticSpec.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput

# Create a simple data function
spec = AnalyticSpec(
    analytic_type='script',
    inputs=[
        AnalyticInput('input_df', 'table', 'input.sbdf')
    ],
    outputs=[
        AnalyticOutput('output_df', 'output.sbdf')
    ],
    script='''
import pandas as pd
output_df = input_df * 2
'''
)

# Enable debugging
spec.enable_debug()

# Execute
result = spec.evaluate()

# Check result
if result.success:
    print("Success!")
else:
    print(f"Error: {result.summary}")
    
# Access debug log
print(result.get_debug_log())
```

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

### Handle SBDFError Scenarios

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/errors.md

Examples demonstrating how to catch and handle common SBDF errors during file operations and type conversions.

```python
import spotfire.sbdf as sbdf

try:
    df = sbdf.import_data('nonexistent.sbdf')
except sbdf.SBDFError as e:
    print(f"Cannot read file: {e}")
```

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({'big_number': [999999999999999999999]})

try:
    # Try to export as Integer (max ~2 billion)
    set_spotfire_types(df, {'big_number': 'Integer'})
    sbdf.export_data(df, 'output.sbdf')
except sbdf.SBDFError as e:
    print(f"Type conversion failed: {e}")
    # Solution: use LongInteger instead
    set_spotfire_types(df, {'big_number': 'LongInteger'})
    sbdf.export_data(df, 'output.sbdf')
```

```python
import pandas as pd
import spotfire.sbdf as sbdf

# Create DataFrame with inconsistent columns (should not happen normally)
try:
    df = pd.DataFrame({
        'col1': [1, 2, 3],
        'col2': [4, 5]  # Wrong length
    })
    sbdf.export_data(df, 'output.sbdf')
except sbdf.SBDFError as e:
    print(f"Column length mismatch: {e}")
```

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

### Evaluating AnalyticSpec and Handling Errors

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Example demonstrating how to evaluate an AnalyticSpec and inspect the resulting AnalyticResult for success or failure.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[],
    outputs=[AnalyticOutput('result', 'out.sbdf')],
    script='result = 1 / 0'  # Division by zero error
)

result = spec.evaluate()

print(f"Success: {result.success}")
print(f"Summary:\n{result.summary}")

if not result.success:
    exc_type, exc_val, exc_tb = result.get_exc_info()
    print(f"Exception: {exc_type.__name__}: {exc_val}")
```

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

### Extract version from Python info

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Static method to generate a version object based on the current Python installation.

```python
@staticmethod
def from_version_info(identifier: int) -> _SpkVersion
```

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

### Build SPK Packages via CLI

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/MODULES.md

Access help documentation for SPK package building commands using the command line interface.

```bash
python -m spotfire.spk python --help
python -m spotfire.spk packages --help
```

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

### Display SPK Help

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Access the command-line help interface for the spotfire.spk module.

```bash
python -m spotfire.spk --help
```

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

### Build Python Package

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Command line instruction to package a Python environment into an SPK file for Spotfire deployment.

```bash
python -m spotfire.spk python \
    --name "Python 3.11" \
    --id "$(python -c 'import uuid; print(uuid.uuid4())')" \
    --output "python311.spk"
```

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

### Build SPK Packages

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/COMPLETION_SUMMARY.txt

Use the command line to build an SPK package based on a requirements file.

```bash
python -m spotfire.spk packages --requirements req.txt
```

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

### Build SPK Packages via CLI

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Commands for building interpreter and package SPKs using the spotfire.spk module.

```bash
python -m spotfire.spk python
```

```bash
python -m spotfire.spk packages
```

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

### Basic SBDF Data Processing

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Demonstrates importing an SBDF file, performing a column transformation, setting Spotfire-specific types, and exporting the result.

```python
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types
import pandas as pd

# Import data
df = sbdf.import_data('input.sbdf')

# Transform data
df['new_column'] = df['existing_column'] * 2

# Set types and export
set_spotfire_types(df, {
    'existing_column': 'Real',
    'new_column': 'Real'
})
sbdf.export_data(df, 'output.sbdf')
```

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

### Access Documentation via Command Line

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/MANIFEST.md

Use standard shell commands to view or search the markdown documentation files.

```bash
# View README
cat README.md

# View specific module
cat api-reference/sbdf.md

# Search for topic
grep -r "export_data" .
```

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

### Build Basic Python SPK

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Programmatically invoke the spotfire.spk CLI to build a base Python package.

```python
import subprocess
import sys
import uuid

# Generate a unique ID
package_id = str(uuid.uuid4())

# Run the python subcommand
subprocess.run([
    sys.executable, '-m', 'spotfire.spk', 'python',
    '--name', 'Python 3.11 Base',
    '--id', package_id,
    '--version', '1.0.0',
    '--output', 'python311_base.spk'
], check=True)
```

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

### Display Project File Structure

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Visual representation of the project directory layout and documentation files.

```text
/workspace/home/output/
├── README.md                          # This file
├── INDEX.md                           # Start here
├── MODULES.md                         # Architecture & dependencies
├── types.md                           # Type system reference
├── errors.md                          # Exception reference
├── configuration.md                   # Configuration options
└── api-reference/
    ├── sbdf.md                        # SBDF module
    ├── public.md                      # Public utilities
    ├── data_function.md               # Data function handler
    └── spk.md                         # SPK package builder
```

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

### Initialize _SpkVersion

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Constructor for creating a new version object with optional components.

```python
def __init__(self, major: int = 1, minor: int = 0, service_pack: int = 0, identifier: int = 0) -> None
```

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

### Configure SPK package via command line

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Basic command-line structure for generating an SPK package with required and optional parameters.

```bash
python -m spotfire.spk python \
    --name "Name"
    --id "ID"
    --version "1.0.0"
    --output "output.spk"
    --requirements "requirements.txt"
    --constraint "constraints.txt"
    --brand '{"key":"value"}'
```

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

### Define and read AnalyticInput

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Demonstrates creating input descriptors for different data types and reading them into a global dictionary.

```python
from spotfire.data_function import AnalyticInput
import spotfire.sbdf as sbdf

# Create inputs
table_input = AnalyticInput('data', 'table', 'input_table.sbdf')
column_input = AnalyticInput('x', 'column', 'column_data.sbdf')
value_input = AnalyticInput('threshold', 'value', 'threshold.sbdf')
null_input = AnalyticInput('optional', 'NULL', '')

# Read into globals
globals_dict = {}
table_input.read(globals_dict, lambda msg: print(f"DEBUG: {msg}"))

# The data is now available
df = globals_dict['data']
```

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

### Define package constraints

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Create a constraints file and apply it during package generation.

```bash
# Create constraints file
cat > constraints.txt << EOF
numpy==1.24.3
pandas==2.2.2
EOF

python -m spotfire.spk packages \
    --requirements requirements.txt \
    --constraint constraints.txt \
    --output packages.spk
```

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

### Define and write AnalyticOutput

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Demonstrates creating an output descriptor and serializing a variable from the global dictionary to an SBDF file.

```python
from spotfire.data_function import AnalyticOutput
import spotfire.sbdf as sbdf
import pandas as pd

# Create output
output = AnalyticOutput('result', 'output_result.sbdf')

# Set up globals with the variable to export
globals_dict = {
    'result': pd.DataFrame({'A': [1, 2, 3]})
}

# Write output
output.write(globals_dict, lambda msg: print(f"DEBUG: {msg}"))
```

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

### packages subcommand

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Builds an SPK containing third-party Python packages.

```APIDOC
## packages subcommand

### Description
Builds an SPK containing only third-party packages specified in requirements.txt, suitable for extending a base Python interpreter SPK. Automatically excludes packages that are already distributed with the Spotfire Python interpreter.

### Command
python -m spotfire.spk packages [arguments]

### Arguments
- **--name** (str) - Required - Package name (displayed in Spotfire)
- **--id** (str) - Required - Unique package identifier (GUID format)
- **--version** (str) - Optional - Version number (X.Y.Z format)
- **--output** (str) - Required - Path for the output SPK file
- **--requirements** (str) - Required - Path to pip requirements.txt file
- **--constraint** (str) - Optional - Path to pip constraints file
- **--brand** (str) - Optional - JSON object to brand into the package metadata
- **--exclude** (str) - Optional - Path patterns to exclude from the package

### Example
python -m spotfire.spk packages --name "ML Libraries" --id "6ba7b810-9dad-11d1-80b4-00c04fd430c8" --version "1.0.0" --output "ml_libs.spk" --requirements ml_requirements.txt
```

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

### Build SPK with Third-Party Packages

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Build an SPK package including dependencies defined in a requirements file.

```bash
# Create requirements file
cat > packages.txt << EOF
scipy>=1.11.0
statsmodels>=0.14.0
matplotlib>=3.8.0
EOF

# Build SPK
python -m spotfire.spk packages \
    --name "Statistical Analysis" \
    --id "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11" \
    --version "1.0.0" \
    --output "statistics_pkg.spk" \
    --requirements packages.txt
```

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

### python subcommand

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Builds an SPK containing a Python interpreter and optional packages.

```APIDOC
## python subcommand

### Description
Builds an SPK package containing the current Python interpreter, the spotfire package, and any dependencies specified in a requirements.txt file.

### Command
python -m spotfire.spk python [arguments]

### Arguments
- **--name** (str) - Required - Package name (displayed in Spotfire)
- **--id** (str) - Required - Unique package identifier (GUID format)
- **--version** (str) - Optional - Version number (X.Y.Z format); defaults to Python version
- **--output** (str) - Required - Path for the output SPK file
- **--requirements** (str) - Optional - Path to pip requirements.txt file
- **--constraint** (str) - Optional - Path to pip constraints file
- **--brand** (str) - Optional - JSON object to brand into the package metadata
- **--exclude** (str) - Optional - Path patterns to exclude from the package

### Example
python -m spotfire.spk python --name "Python with ML" --id "550e8400-e29b-41d4-a716-446655440000" --version "1.0.0" --output "python_ml.spk" --requirements requirements.txt --brand '{"author":"Data Science Team", "contact":"datascience@company.com"}'
```

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

### Import and Inspect SBDF Data

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Use the sbdf module to load data files and inspect their structure and Spotfire-specific types.

```python
import spotfire.sbdf as sbdf
from spotfire.public import get_spotfire_types

df = sbdf.import_data('data.sbdf')
print(df.info())
print(get_spotfire_types(df))
```

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

### Define output path

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Specify the destination file path for the generated SPK file.

```bash
python -m spotfire.spk python \
    --output /tmp/python_pkg.spk
```

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

### Configure GeoDataFrame for Spotfire geocoding

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/public.md

Prepares a GeoDataFrame for map visualization by calculating geometry bounds and encoding data into WKB format. Requires uniform geometry types to avoid SBDFError.

```python
import geopandas as gpd
from shapely.geometry import Point, Polygon
from spotfire.public import set_geocoding_table
import spotfire.sbdf as sbdf

# Create a GeoDataFrame with point geometries
data = {
    'name': ['Location A', 'Location B', 'Location C'],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)]
}

gdf = gpd.GeoDataFrame(data, crs='EPSG:4326')

# Configure as geocoding table
set_geocoding_table(gdf)

# Export to Spotfire
sbdf.export_data(gdf, 'geocoding_table.sbdf')

# With polygon data
polygon_data = {
    'region': ['North', 'South', 'East'],
    'geometry': [
        Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]),
        Polygon([(1, 0), (2, 0), (2, 1), (1, 1)]),
        Polygon([(2, 0), (3, 0), (3, 1), (2, 1)])
    ]
}

polygon_gdf = gpd.GeoDataFrame(polygon_data, crs='EPSG:4326')
set_geocoding_table(polygon_gdf)
sbdf.export_data(polygon_gdf, 'regions.sbdf')
```

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

### Configure SPOTFIRE_PACKAGES environment variable

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Defines the directory containing extracted SPK files for the Spotfire server.

```bash
# Spotfire server sets this during runtime
export SPOTFIRE_PACKAGES=/opt/spotfire/packages
```

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

### Define Optional Dependencies

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/MODULES.md

Lists the optional dependency groups for geographic and plotting functionality.

```text
spotfire[geo]/
    ├── geopandas
    └── shapely >= 2.0.4

spotfire[plot]/
    ├── matplotlib >= 3.8.4
    ├── seaborn >= 0.13.2
    └── pillow >= 10.0.0
```

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

### Initialize AnalyticSpec

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Basic constructor usage for the AnalyticSpec class.

```python
spec = AnalyticSpec(
    analytic_type="script",         # Config parameter
    inputs=[...],                   # Config parameter
    outputs=[...],                  # Config parameter
    script="..."                    # Config parameter
)

spec.enable_debug()                 # Config option
spec.set_script_filename(name)      # Config option
```

```python
from spotfire.data_function import AnalyticSpec

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[],
    outputs=[],
    script='result = 42'
)
```

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

### Capture SBDF warnings

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/sbdf.md

Demonstrates how to use the warnings module to catch and process SBDFWarning instances during data operations.

```python
import warnings
import spotfire.sbdf as sbdf

# Capture SBDF warnings
with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    sbdf.set_spotfire_types(df, {'col': 'UnknownType'})
    
    if w:
        for warning in w:
            if issubclass(warning.category, sbdf.SBDFWarning):
                print(f"Warning: {warning.message}")
```

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

### Configure PYTHONPATH environment variable

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Sets the Python path to ensure the spotfire package and its dependencies are discoverable.

```bash
export PYTHONPATH=/usr/local/lib/python3.11/site-packages:$PYTHONPATH
python -c "import spotfire; print(spotfire.__version__)"
```

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

### Embed package metadata

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Use the --brand parameter to pass a JSON string containing package metadata.

```bash
python -m spotfire.spk python \
    --brand '{"author":"Data Team","contact":"data@company.com","url":"https://data.company.com"}' \
    --output python.spk
```

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

### Define package requirements

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Format for a requirements.txt file and the corresponding command to include it in an SPK package.

```text
numpy>=1.23.5
pandas>=2.2.2
scikit-learn>=1.3.0
matplotlib>=3.8.0
```

```bash
python -m spotfire.spk packages \
    --requirements /path/to/requirements.txt \
    --output packages.spk
```

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

### import_data(sbdf_file)

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/sbdf.md

Reads an SBDF file and reconstructs the tabular data as a pandas DataFrame, preserving Spotfire-specific metadata.

```APIDOC
## import_data(sbdf_file)

### Description
Import data from an SBDF file and create a pandas DataFrame. The function preserves Spotfire-specific metadata attached to the table and columns.

### Parameters
- **sbdf_file** (str | PathLike) - Required - Path to the SBDF file to import

### Returns
- **pd.DataFrame** - The imported data with metadata and column information preserved.

### Raises
- **SBDFError** - If a problem occurs during import (file not found, corrupted data, unsupported version).
```

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

### Modify Data and Re-export

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Demonstrates how to perform basic column operations on a dataframe and save the result back to an SBDF file.

```python
import spotfire.sbdf as sbdf
from spotfire.public import copy_metadata, set_spotfire_types

df = sbdf.import_data('input.sbdf')
df['new_column'] = df['existing_column'] * 2

sbdf.export_data(df, 'output.sbdf')
```

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

### Manage SPK Versions

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Use the _SpkVersion class to create, increment, decrement, and parse SPK version strings.

```python
from spotfire.spk import _SpkVersion

# Create a version
version = _SpkVersion(1, 0, 0, 0)
print(f"Initial: {version}")  # 1.0.0.0

# Increment minor
version.increment_minor()
print(f"After increment_minor: {version}")  # 1.1.0.0

# Decrement back
version.decrement_minor()
print(f"After decrement_minor: {version}")  # 1.0.0.0

# Parse from string
v2 = _SpkVersion.from_str("2.5.10")
print(f"Parsed: {v2}")  # 2.5.10.0
```

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

### Verify SBDF file existence

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Use this to confirm the file path is correct before attempting to load or process an SBDF file.

```python
import os
print(os.path.exists('data.sbdf'))
```

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

### Parse version string

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Static method to create a version object from a dot-separated string.

```python
@staticmethod
def from_str(str_: str) -> _SpkVersion
```

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

### Configure encoding_rle for SBDF export

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Toggles RLE compression to optimize for either file size or I/O speed.

```python
import pandas as pd
import spotfire.sbdf as sbdf

df = pd.DataFrame({'values': [1, 1, 1, 2, 2, 3]})

# With compression (default)
sbdf.export_data(df, 'compressed.sbdf', encoding_rle=True)

# Without compression
sbdf.export_data(df, 'uncompressed.sbdf', encoding_rle=False)
```

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

### Build Third-Party Packages SPK

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Syntax for building an SPK containing only third-party Python packages.

```bash
python -m spotfire.spk packages \
    --name <package-name> \
    --id <package-id> \
    --version <version> \
    --output <output-file> \
    --requirements <file> \
    [--constraint <file>] \
    [--brand <brand-json>]
```

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

### Define CLI Subcommand

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Use the subcommand and argument decorators to register custom CLI commands for the spotfire.spk module.

```python
from spotfire.spk import subcommand, argument

@subcommand(args=[
    argument('--input', required=True, help='Input file'),
    argument('--output', required=True, help='Output file'),
])
def custom_command(args):
    """Custom SPK command."""
    print(f"Processing {args.input} -> {args.output}")
```

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

### Configure PATH environment variable

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Updates the system PATH to include the directory containing the Python interpreter for SPK packages.

```bash
# Extended by SPK package deployment
export PATH=/opt/spotfire/python/bin:$PATH
```

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

### Define SBDF export parameters

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Shows the signature for the export_data function with configuration parameters.

```python
sbdf.export_data(
    obj,
    sbdf_file,
    default_column_name="x",        # Config parameter
    rows_per_slice=0,                # Config parameter
    encoding_rle=True                # Config parameter
)
```

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

### Build Python Interpreter SPK

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Syntax for building an SPK containing a Python interpreter and optional packages.

```bash
python -m spotfire.spk python \
    --name <package-name> \
    --id <package-id> \
    --version <version> \
    --output <output-file> \
    [--requirements <file>] \
    [--constraint <file>] \
    [--brand <brand-json>]
```

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

### Import and Export SBDF Data

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/COMPLETION_SUMMARY.txt

Use these commands to read data from an SBDF file and write data back to an SBDF file.

```python
import spotfire.sbdf as sbdf
df = sbdf.import_data('data.sbdf')
```

```python
sbdf.export_data(df, 'output.sbdf')
```

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

### Capture warnings during type setting

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/errors.md

Use the warnings module to intercept and process warnings generated during type conversion before proceeding with data export.

```python
import warnings
import pandas as pd
from spotfire.public import set_spotfire_types
import spotfire.sbdf as sbdf

df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})

with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    
    set_spotfire_types(df, {
        'col1': 'Integer',
        'col2': 'UnknownType',  # Will generate warning
        'col3': 'String'        # Will generate warning
    })
    
    # Check for warnings
    for warning in w:
        print(f"Warning: {warning.message}")
    
    # Proceed with export despite warnings
    try:
        sbdf.export_data(df, 'output.sbdf')
    except sbdf.SBDFError as e:
        print(f"Export failed: {e}")
```

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

### Store Custom Column Metadata

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Shows how to attach custom metadata to a pandas DataFrame column using the spotfire_column_metadata attribute.

```python
import pandas as pd

df = pd.DataFrame({'amount': [100.0, 200.0]})

# Store custom metadata
df['amount'].spotfire_column_metadata = {
    'Format': 'Currency',
    'Decimal Places': '2',
    'Currency Code': 'USD'
}
```

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

### Define _SpkVersion class

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Basic class definition for _SpkVersion.

```python
class _SpkVersion
```

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

### export_data(obj, sbdf_file, default_column_name, rows_per_slice, encoding_rle)

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/sbdf.md

Exports various Python data structures to Spotfire Binary Data Format (SBDF).

```APIDOC
## export_data(obj, sbdf_file, default_column_name, rows_per_slice, encoding_rle)

### Description
Exports various Python data structures (DataFrame, Series, ndarray, dict, scalar, PIL Image, matplotlib Figure, seaborn Grid, or iterable) to an SBDF file.

### Parameters
- **obj** (Any) - Required - Data object to export
- **sbdf_file** (str | PathLike) - Required - Path where the SBDF file will be written
- **default_column_name** (str) - Optional - Column name to use for data without intrinsic names (default: "x")
- **rows_per_slice** (int) - Optional - Number of rows per table slice; 0 means auto-determine (default: 0)
- **encoding_rle** (bool) - Optional - Whether to use RLE (Run-Length Encoding) for table slices (default: True)

### Raises
- **SBDFError** - If a problem occurs during export (inconsistent column lengths, unsupported types, file I/O errors).
```

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

### Invoke SPK Module CLI

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

General syntax for invoking the SPK module via the command line.

```bash
python -m spotfire.spk <subcommand> [arguments]
```

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

### @subcommand(args=None, parent=CLI_SUBPARSERS)

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

Decorator used to register a function as a CLI subcommand for the spotfire.spk CLI. The decorated function's docstring is used as the help text.

```APIDOC
## @subcommand

### Description
Decorator to register a function as a CLI subcommand for the `python -m spotfire.spk` CLI.

### Parameters
- **args** (list) - Optional - List of argument tuples to add to the subcommand.
- **parent** (ArgumentParser) - Optional - Parent argument parser (defaults to CLI_SUBPARSERS).
```

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

### Perform Basic SBDF Operations

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/MODULES.md

Use these functions to import data from and export data to SBDF files.

```python
import spotfire.sbdf as sbdf

df = sbdf.import_data('file.sbdf')
sbdf.export_data(df, 'output.sbdf')
```

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

### Specify Spotfire column types

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Explicitly define column types to resolve conversion errors and improve performance.

```python
from spotfire.public import set_spotfire_types
set_spotfire_types(df, {'column': 'LongInteger'})
```

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

### Export and Import Data with Invalid Values

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Demonstrates how to handle missing values using None, which are preserved during SBDF export and import cycles.

```python
import pandas as pd
import numpy as np
import spotfire.sbdf as sbdf

df = pd.DataFrame({
    'numbers': [1, 2, None, 4, 5],
    'text': ['a', None, 'c', 'd', 'e']
})

sbdf.export_data(df, 'with_nulls.sbdf')

# On import, None values are preserved
imported = sbdf.import_data('with_nulls.sbdf')
print(pd.isnull(imported['numbers']))  # [False False True False False]
```

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

### Execute Data Function Workflow

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Standard workflow for defining inputs/outputs, configuring the AnalyticSpec, and executing the script.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput
import pandas as pd

# Define the data function
spec = AnalyticSpec(
    analytic_type='script',
    inputs=[
        AnalyticInput('sales', 'table', 'sales_input.sbdf'),
        AnalyticInput('min_value', 'value', 'threshold.sbdf')
    ],
    outputs=[
        AnalyticOutput('filtered', 'filtered_output.sbdf'),
        AnalyticOutput('summary', 'summary_output.sbdf')
    ],
    script='''
# Filter sales by threshold
filtered = sales[sales['amount'] > min_value]

# Create summary
summary = pd.DataFrame({
    'metric': ['total_rows', 'filtered_rows'],
    'count': [len(sales), len(filtered)]
})
'''
)

# Execute
result = spec.evaluate()

if result.success:
    print("Data function completed successfully")
    print(f"Stdout: {result.get_capture().get_stdout()}")
else:
    print(f"Error: {result.summary}")
```

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

### Export DateTime data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the DateTime Spotfire type using datetime objects.

```python
import pandas as pd
from datetime import datetime
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({
    'timestamp': [
        datetime(2024, 1, 15, 10, 30, 45),
        datetime(2024, 1, 16, 14, 22, 30)
    ]
})
set_spotfire_types(df, {'timestamp': 'DateTime'})
sbdf.export_data(df, 'datetime.sbdf')
```

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

### Enable Debug Logging

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Methods to enable and retrieve debug logs for data function execution.

```python
spec.enable_debug()
```

```python
from spotfire.data_function import AnalyticSpec, AnalyticOutput

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[],
    outputs=[AnalyticOutput('x', 'out.sbdf')],
    script='x = 123'
)

spec.enable_debug()

result = spec.evaluate()

if result.success:
    print("Debug log:")
    print(result.get_debug_log())
```

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

### Export Integer data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the Integer Spotfire type before exporting.

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({'count': [1, 100, -500]})
set_spotfire_types(df, {'count': 'Integer'})
sbdf.export_data(df, 'integers.sbdf')
```

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

### Set explicit types for performance

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Use set_spotfire_types to pre-assign data types, which is more efficient than relying on automatic inference during export.

```python
import pandas as pd
from spotfire.public import set_spotfire_types
import spotfire.sbdf as sbdf

df = pd.DataFrame({...})

# Set types explicitly (faster than inference)
set_spotfire_types(df, {
    'id': 'Integer',
    'amount': 'Currency',
    'name': 'String'
})

sbdf.export_data(df, 'output.sbdf')
```

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

### Execute a Data Function

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Define an analytic specification with inputs and outputs, then evaluate the script.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput

# Define function
spec = AnalyticSpec(
    analytic_type='script',
    inputs=[
        AnalyticInput('input_df', 'table', 'input.sbdf')
    ],
    outputs=[
        AnalyticOutput('result_df', 'output.sbdf')
    ],
    script='''
import pandas as pd
result_df = input_df * 2
'''
)

# Execute
result = spec.evaluate()

if result.success:
    print("Success!")
else:
    print(f"Error: {result.summary}")
```

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

### Export LongInteger data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the LongInteger Spotfire type before exporting.

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({'id': [1234567890123, 9876543210987]})
set_spotfire_types(df, {'id': 'LongInteger'})
sbdf.export_data(df, 'long_integers.sbdf')
```

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

### Export SingleReal data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the SingleReal Spotfire type before exporting.

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({'value': [1.5, 2.7, 3.14]})
set_spotfire_types(df, {'value': 'SingleReal'})
sbdf.export_data(df, 'single_real.sbdf')
```

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

### Execute Analytic Data Function

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/README.md

Define an analytic specification with inputs and outputs, then evaluate the script.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[AnalyticInput('data', 'table', 'input.sbdf')],
    outputs=[AnalyticOutput('result', 'output.sbdf')],
    script='result = data * 2'
)

result = spec.evaluate()
print(f"Success: {result.success}")
```

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

### Export Date data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the Date Spotfire type using date objects.

```python
import pandas as pd
from datetime import date
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({
    'event_date': [
        date(2024, 1, 15),
        date(2024, 1, 16)
    ]
})
set_spotfire_types(df, {'event_date': 'Date'})
sbdf.export_data(df, 'dates.sbdf')
```

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

### AnalyticResult Methods

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Methods for retrieving detailed debug logs, exception information, and output captures.

```python
def get_debug_log(self) -> str | None
```

```python
def get_exc_info(self) -> tuple[type[BaseException] | None, BaseException | None, TracebackType | None]
```

```python
def get_capture(self) -> _OutputCapture
```

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

### Export String data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Map standard Python strings to the Spotfire String type for Unicode text data.

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie']
})
set_spotfire_types(df, {'name': 'String'})
sbdf.export_data(df, 'strings.sbdf')
```

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

### copy_metadata(source, destination)

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/public.md

Copies all Spotfire-specific table and column metadata from a source pandas DataFrame or Series to a destination object.

```APIDOC
## copy_metadata(source, destination)

### Description
Copies all Spotfire-specific metadata from one pandas object to another. This includes table metadata for DataFrames and column metadata for both DataFrames and Series.

### Parameters
- **source** (pd.DataFrame | pd.Series) - Required - Source object to copy metadata from
- **destination** (pd.DataFrame | pd.Series) - Required - Destination object to copy metadata to

### Raises
- **TypeError** - Raised if source and destination types do not match (both must be DataFrames or both must be Series).
```

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

### Manage Metadata and Spotfire Types

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/MODULES.md

Functions for copying metadata between dataframes and setting specific Spotfire data types.

```python
from spotfire.public import copy_metadata, set_spotfire_types
from spotfire import copy_metadata  # Alternative via __init__

copy_metadata(source_df, dest_df)
set_spotfire_types(df, {'col': 'Integer'})
```

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

### AnalyticSpec Constructor

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Initializes a new AnalyticSpec instance for defining data functions.

```APIDOC
## AnalyticSpec(analytic_type, inputs, outputs, script)

### Description
Creates a new analytic specification for executing scripts.

### Parameters
- **analytic_type** (str) - Required - Type of analytics function; only "script" is supported.
- **inputs** (list) - Optional - List of input definitions.
- **outputs** (list) - Optional - List of output definitions.
- **script** (str) - Optional - The script content to execute.

### Example
```python
from spotfire.data_function import AnalyticSpec

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[],
    outputs=[],
    script='result = 42'
)
```
```

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

### Export Currency data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Use decimal.Decimal objects to ensure arbitrary-precision for financial calculations when mapping to the Currency type.

```python
import pandas as pd
from decimal import Decimal
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

df = pd.DataFrame({
    'price': [
        Decimal('19.99'),
        Decimal('29.95'),
        Decimal('1234.56')
    ]
})
set_spotfire_types(df, {'price': 'Currency'})
sbdf.export_data(df, 'currency.sbdf')
```

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

### _SpkVersion Class

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

The _SpkVersion class represents a version number in Spotfire SPK package format. It supports initialization, parsing from strings, and extracting version info from the current Python environment.

```APIDOC
## _SpkVersion

### Constructor
`_SpkVersion(major: int = 1, minor: int = 0, service_pack: int = 0, identifier: int = 0)`

### Static Methods
- `from_str(str_: str) -> _SpkVersion`: Parses a dot-separated version string into a _SpkVersion object.
- `from_version_info(identifier: int) -> _SpkVersion`: Extracts the SPK version from the running Python installation.

### Instance Methods
- `increment_major()`: Increments major version and resets others to zero.
- `increment_minor()`: Increments minor version and resets service pack and identifier to zero.
- `decrement_major()`: Decrements major version and resets others to zero.
- `decrement_minor(wrap_around: int = 99)`: Decrements minor version and resets service pack and identifier to zero.
- `decrement_service_pack(wrap_around: int = 99)`: Decrements service pack and resets identifier to zero.
```

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

### Export Time data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/types.md

Explicitly set a column to the Time Spotfire type using timezone-aware time objects.

```python
import pandas as pd
from datetime import time, timezone, timedelta
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

tz = timezone(timedelta(hours=-5))  # EST
df = pd.DataFrame({
    'event_time': [
        time(10, 30, 45, tzinfo=tz),
        time(14, 22, 30, tzinfo=tz)
    ]
})
set_spotfire_types(df, {'event_time': 'Time'})
sbdf.export_data(df, 'times.sbdf')
```

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

### set_geocoding_table(dataframe)

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/public.md

Configures a GeoDataFrame for export as a Spotfire geocoding table, enabling map visualization support.

```APIDOC
## set_geocoding_table(dataframe)

### Description
Prepares a GeoDataFrame for export as a Spotfire geocoding table. It calculates bounds and centroids, sets metadata, and encodes geometry in Well-Known Binary (WKB) format.

### Signature
`def set_geocoding_table(dataframe: gpd.GeoDataFrame) -> None`

### Parameters
- **dataframe** (gpd.GeoDataFrame) - Required - GeoDataFrame to configure for geocoding.

### Exceptions
- **sbdf.SBDFError**: Raised if geometry types are mixed or unknown.

### Supported Geometry Types
Point, LineString, LinearRing, MultiLineString, Polygon
```

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

### Inspect data function execution results

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/errors.md

Check the success status of an analytic evaluation and use get_exc_info to diagnose specific script failures.

```python
from spotfire.data_function import AnalyticSpec, AnalyticInput, AnalyticOutput

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[AnalyticInput('input', 'table', 'input.sbdf')],
    outputs=[AnalyticOutput('output', 'output.sbdf')],
    script='output = input * 2'
)

result = spec.evaluate()

if not result.success:
    # Check for different error types
    exc_type, exc_val, exc_tb = result.get_exc_info()
    
    if exc_type is KeyError:
        print(f"Missing variable: {exc_val}")
    elif exc_type is TypeError:
        print(f"Type error in script: {exc_val}")
    else:
        print(f"Script error: {result.summary}")
else:
    print("Data function executed successfully")
```

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

### AnalyticResult Properties

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/data_function.md

Properties for checking execution status and retrieving output logs or warnings.

```python
@property
def success(self) -> bool
```

```python
@property
def has_stderr(self) -> bool
```

```python
@property
def has_warnings(self) -> bool
```

```python
@property
def std_err_out(self) -> str | None
```

```python
@property
def warnings(self) -> list[str]
```

```python
@property
def summary(self) -> str | None
```

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

### SPK File Structure

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/api-reference/spk.md

The directory layout of a generated SPK ZIP archive.

```text
package.spk
├── [Python Interpreter Files]
├── Lib/site-packages/        # Third-party packages (packages SPK only)
├── spotfire-packages/        # Spotfire Python package files
├── requirements-name.txt     # Requirements file (packages SPK only)
└── constraints-name.txt      # Constraints file (if provided)
```

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

### Generate a unique package ID

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/configuration.md

Use the uuid library to generate a compliant UUID for the --id parameter.

```python
import uuid
package_id = str(uuid.uuid4())
print(package_id)
```

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

### Export Data to SBDF

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/INDEX.md

Convert a pandas DataFrame to SBDF format, applying specific Spotfire data types before export.

```python
import pandas as pd
import spotfire.sbdf as sbdf
from spotfire.public import set_spotfire_types

# Create DataFrame
df = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie'],
    'salary': [50000, 60000, 75000]
})

# Set Spotfire types
set_spotfire_types(df, {
    'id': 'Integer',
    'name': 'String',
    'salary': 'Currency'
})

# Export
sbdf.export_data(df, 'employees.sbdf')
```

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

### Inspect Exception Information

Source: https://github.com/spotfiresoftware/spotfire-python/blob/main/_autodocs/errors.md

Access exception details including type, value, and traceback objects using get_exc_info() after an evaluation failure.

```python
from spotfire.data_function import AnalyticSpec
import traceback

spec = AnalyticSpec(
    analytic_type='script',
    inputs=[],
    outputs=[],
    script='1 / 0'  # Division by zero
)

result = spec.evaluate()

exc_type, exc_val, exc_tb = result.get_exc_info()

if exc_type:
    print(f"Exception type: {exc_type.__name__}")
    print(f"Exception value: {exc_val}")
    if exc_tb:
        print("Traceback:")
        traceback.print_tb(exc_tb)
```
Tokens:
Raw