Import Export and Data Exchange

Every format in and out of a project: PDF/DXF/DWG/graphics/PXF exports, DC/XML data exchange, PLC, parts management, macros, ribbon, production data, labels.

59 tools (all prefixed eplan_ when registered as MCP tools).

`eplan_export_pdf_project`

eplan_export_pdf_project(export_file: str, project_name: str=None, export_scheme: str=None, black_white: int=0, language: str=None, use_zoom: bool=False, zoom_level: int=None, use_simple_link: bool=False, fast_web_view: bool=False, read_only: bool=False, use_print_margins: bool=None, export_model: bool=False)

Export project to PDF format (with QuietMode - no dialogs). Action: export

WARNING - omitting export_scheme can silently change where the PDF goes. Measured 2026-09-03 on EPLAN 2027.0.1, reproduced 3x: with export_scheme omitted this returned {“success”: true} and wrote “-1.pdf” instead of the requested filename. Per EPLAN’s docs an absent EXPORTSCHEME makes it use “the most recently used” export scheme, and that scheme’s own output settings override EXPORTFILE’s basename. Supplying a valid scheme honoured the requested path exactly.

The fallback scheme is readable, so you do not have to guess: list the schemes with settings_list_children(“USER.PDFExportGUI.SCHEMAS”) and read which one EPLAN will fall back to with settings_get_string(“USER.PDFExportGUI.SCHEMAS.LastUsed”). Pass an explicit export_scheme whenever the output filename matters, and verify the file on disk afterwards rather than trusting success:true.

The result says which files were really written. requestedFile is what you asked for, requestedFileWritten says whether that exact basename appeared or changed, and writtenFiles lists every file that changed in the target directory during the call. When the requested basename is absent, note explains it. If the directory could not be listed, verification says so rather than claiming nothing was written.

Args: export_file: Output PDF file path. The directory is honoured; the basename can be overridden by the scheme (see WARNING above). project_name: Project path (optional) export_scheme: PDF export scheme name. Optional to EPLAN, but treat it as required whenever you care about the output filename. black_white: 0=Color, 1=B&W, 2=Grayscale, 3=White Inverted language: Language code (e.g., “en_US”) use_zoom: Enable zoom window for navigation zoom_level: Zoom level in mm (1-3500) use_simple_link: Only create simple links in PDF (no three-way jumps) fast_web_view: Enable fast web display read_only: Make PDF write-protected use_print_margins: Use print margins (None=from scheme) export_model: Export 3D models along with pages

`eplan_export_pdf_pages`

eplan_export_pdf_pages(export_file: str, page_names: List[str]=None, page_identifiers: List[str]=None, project_name: str=None, export_scheme: str=None, black_white: int=0, language: str=None, use_zoom: bool=False, zoom_level: int=None, use_simple_link: bool=False, fast_web_view: bool=False, read_only: bool=False, use_print_margins: bool=None, export_model: bool=False)

Export specific pages to PDF format (with QuietMode - no dialogs). Action: export

WARNING - same scheme hazard as export_pdf_project: with export_scheme omitted EPLAN falls back to “the most recently used” export scheme, whose output settings can override EXPORTFILE’s basename while the call still returns success:true. Also observed on a production project (2026-09-01), where the written basename came from the scheme, not from the request, and the caller only found out by listing the directory. Read the fallback with settings_get_string(“USER.PDFExportGUI.SCHEMAS.LastUsed”), pass an explicit export_scheme when the filename matters, and check the file on disk.

Args: export_file: Output PDF file path. Directory honoured; basename can be overridden by the scheme (see WARNING above). page_names: List of page names (e.g., [“=AP+ST1/2”, “=AP+ST1/4”]) page_identifiers: List of page identifiers from StorableObject.ToStringIdentifier() project_name: Project path (optional) export_scheme: PDF export scheme name. Optional to EPLAN, but treat as required whenever you care about the output filename. black_white: 0=Color, 1=B&W, 2=Grayscale, 3=White Inverted language: Language code use_zoom: Enable zoom window zoom_level: Zoom level in mm (1-3500) use_simple_link: Only simple links fast_web_view: Enable fast web display read_only: Write-protected PDF use_print_margins: Use print margins export_model: Export 3D models

`eplan_export_dxf_project`

eplan_export_dxf_project(destination_path: str, project_name: str=None, export_scheme: str=None, language: str=None, target: str=None)

Export project to DXF format. Action: export

Args: destination_path: Output directory project_name: Project path (optional) export_scheme: DXF export scheme language: Language code (case-sensitive, e.g., “en_US”) target: “Disk” or “FromSettings”

`eplan_export_dxf_pages`

eplan_export_dxf_pages(destination_path: str=None, page_name: str=None, page_names: List[str]=None, project_name: str=None, export_scheme: str=None, language: str=None, target: str=None)

Export pages to DXF format. Action: export

Args: destination_path: Output directory (ignored if using PAGENAMEn with scheme) page_name: Single page name page_names: List of page names for multiple export project_name: Project path (optional) export_scheme: DXF export scheme language: Language code target: “Disk” or “FromSettings”

`eplan_export_dwg_project`

eplan_export_dwg_project(destination_path: str, project_name: str=None, export_scheme: str=None, language: str=None, target: str=None)

Export project to DWG format. Action: export

Args: destination_path: Output directory project_name: Project path (optional) export_scheme: DWG export scheme language: Language code target: “Disk” or “FromSettings”

`eplan_export_dwg_pages`

eplan_export_dwg_pages(destination_path: str=None, page_name: str=None, page_names: List[str]=None, project_name: str=None, export_scheme: str=None, language: str=None, target: str=None)

Export pages to DWG format. Action: export

Args: destination_path: Output directory page_name: Single page name page_names: List of page names project_name: Project path (optional) export_scheme: DWG export scheme language: Language code target: “Disk” or “FromSettings”

`eplan_export_dxfdwg_project_scheme`

eplan_export_dxfdwg_project_scheme(project_name: str=None, export_scheme: str=None, language: str=None, target: str='FromSettings')

Export project to DXF or DWG format using scheme settings. Format (DXF or DWG) is determined by the scheme. Action: export

Args: project_name: Project path (optional) export_scheme: Export scheme (determines DXF or DWG) language: Language code target: “Disk” or “FromSettings” (default)

`eplan_export_dxfdwg_pages_scheme`

eplan_export_dxfdwg_pages_scheme(page_names: List[str]=None, page_identifiers: List[str]=None, project_name: str=None, export_scheme: str=None, language: str=None, target: str='FromSettings')

Export pages to DXF or DWG format using scheme settings. Format is determined by the scheme. Action: export

Args: page_names: List of page names page_identifiers: List of page identifiers (SELn) project_name: Project path (optional) export_scheme: Export scheme language: Language code target: “Disk” or “FromSettings”

`eplan_export_graphics_project`

eplan_export_graphics_project(destination_path: str, project_name: str=None, format: str='PNG', color_depth: int=24, image_width: int=1024, black_white: bool=False, compression: str='NONE')

Export project to graphical format (PNG, TIF, GIF, JPG, BMP). Action: export

Args: destination_path: Output directory project_name: Project path (optional) format: Image format - “PNG”, “TIF”, “GIF”, “JPG”, “BMP” color_depth: 1, 4, 8, 16, 24, or 32 image_width: Image width in pixels black_white: Black and white output compression: For TIF - “LZW”, “RLE”, “CCITT3”, “CCITT4”, “NONE”

`eplan_export_graphics_pages`

eplan_export_graphics_pages(destination_path: str, page_name: str=None, project_name: str=None, format: str='PNG', color_depth: int=24, image_width: int=1024, black_white: bool=False, compression: str='NONE', use_page_filter: bool=False)

Export pages to graphical format (PNG, TIF, GIF, JPG, BMP). Action: export

Args: destination_path: Output directory page_name: Specific page name (optional, if not set uses filter or all) project_name: Project path (optional) format: Image format - “PNG”, “TIF”, “GIF”, “JPG”, “BMP” color_depth: 1, 4, 8, 16, 24, or 32 image_width: Image width in pixels black_white: Black and white output compression: For TIF - “LZW”, “RLE”, “CCITT3”, “CCITT4”, “NONE” use_page_filter: Use active page filter (ignored if page_name is set)

`eplan_export_pxf_project`

eplan_export_pxf_project(export_file: str, project_name: str=None, export_masterdata: bool=True, export_connections: bool=False)

Export project in EPJ/PXF format. Action: export

EPLAN appends the extension itself, so the file on disk is normally NOT the basename you passed. The result reports the difference rather than echoing the request back: requestedFile, requestedFileWritten, and writtenFiles - every file that changed in the target directory during the call. Unlike the PDF wrappers this has not been measured live; the shape of the mutation is taken from EPLAN’s own documented behaviour.

Args: export_file: Output file path (extension added automatically) project_name: Project path (optional) export_masterdata: Include master data (default True) export_connections: Include connections (default False)

`eplan_export_3d`

eplan_export_3d(destination_path: str, type: str, project_name: str=None, installation_space: str=None, export_scheme: str=None, separate_files: bool=None, filename: str=None)

Export installation spaces to 3D formats. Action: export3d

Live-verified 2026-09-04 (2025.0.3, Pro Panel licensed): the previous wrapper sent FORMAT/INSTALLATIONSPACE, neither a real export3d parameter, and never sent the mandatory TYPE - EPLAN answered every call with “Este proceso no es compatible.” and nothing was written. See Audit #42 item 1.

Args: destination_path: Output directory. Created if it does not exist. type: “STEP” or “JT”. Mandatory - the action has no default and silently rejects the call without it. project_name: Project path (optional). Required if there is no project with focus in the EPLAN GUI. installation_space: Name of the layout space to export. If omitted, the entire project is exported. export_scheme: Export scheme (optional). Only effective with type=“STEP”; if omitted the last-used scheme applies. separate_files: Write one file per installation space instead of a single combined file (optional). Only effective with type=“STEP”. filename: Output file name (optional). Only effective with type=“JT”.

`eplan_export_to_graphics`

eplan_export_to_graphics(destination_path: str, type: str='GRAPHICPROJECT', project_name: str=None, page_name: str=None, export_scheme: str=None, format: str=None, color_depth: int=None, image_width: int=None, image_compression: str=None, black_white: bool=None, use_page_filter: bool=None)

Export pages or a whole project to a graphical format (TIF, GIF, PNG, JPG, BMP). Action: exportToGraphics

How this differs from export_graphics_project / export_graphics_pages (which drive the generic “export” action with TYPE=GRAPHICPROJECT / TYPE=GRAPHICPAGE): both reach the same graphical export, but the generic “export” wrappers take no EXPORTSCHEME and therefore hard-code FORMAT, COLORDEPTH and IMAGEWIDTH on every call. exportToGraphics is the dedicated, scheme-driven entry point: pass export_scheme and leave the image options None so the scheme supplies them, and it additionally exposes USEPAGEFILTER for project-level exports.

Use export_to_graphics when a graphical export scheme is configured in the project (the normal case) or when you need USEPAGEFILTER. Use the older export_graphics_project / export_graphics_pages when you want to state every image option explicitly with no scheme involved.

Note the documented default of BLACKWHITE is 1 - leaving black_white None yields a black/white image, unlike export_graphics_project whose black_white defaults to False (color).

Args: destination_path: Target directory. Created if missing. For a project export a subdirectory named after the project is created below it. type: “GRAPHICPROJECT” (whole project) or “GRAPHICPAGE” (pages) project_name: Project path with full path (optional; selected project if omitted) page_name: Page to export - only effective with type=“GRAPHICPAGE” export_scheme: Graphical export scheme; supplies defaults for the other optional parameters. Most recently used scheme if omitted. format: Output format - “BMP”, “TIF”, “GIF”, “PNG”, “JPG” color_depth: 1, 8, 16, 24 or 32 (format dependent) image_width: Image width in pixels; height follows the page dimensions image_compression: TIF only - “LZW”, “RLE”, “CCITT3”, “CCITT4”, “NONE”. CCITT3/CCITT4/RLE force color depth 1. black_white: Output in black and white. Documented default: 1 (true). use_page_filter: Export only filtered pages instead of all project pages (matches the “Active” check box in the page navigator).

`eplan_import_pxf_project`

eplan_import_pxf_project(import_file: str, project_name: str, balance_articles: bool=False, generate_auto_cables: bool=False, verify: bool=False)

Import a PXF/EPJ project. Action: import

Args: import_file: Path to PXF file project_name: Target project path balance_articles: Sync parts with database generate_auto_cables: Generate automatic cables verify: Run project check after import

`eplan_import_dwg_page`

eplan_import_dwg_page(import_file: str, page_name: str, project_name: str=None, import_scheme: str=None, x_scale: float=1.0, y_scale: float=1.0, x_offset: float=0.0, y_offset: float=0.0)

Insert DWG drawing into a page. Action: import

Args: import_file: Path to DWG file page_name: Target page name project_name: Project path (optional) import_scheme: DWG import scheme name (without path) x_scale: Scaling in X direction (default 1.0) y_scale: Scaling in Y direction (default 1.0) x_offset: Move in X direction (default 0.0) y_offset: Move in Y direction (default 0.0)

`eplan_import_dxf_page`

eplan_import_dxf_page(import_file: str, page_name: str, project_name: str=None, import_scheme: str=None, x_scale: float=1.0, y_scale: float=1.0, x_offset: float=0.0, y_offset: float=0.0)

Insert DXF drawing into a page. Action: import

Args: import_file: Path to DXF file page_name: Target page name project_name: Project path (optional) import_scheme: DXF import scheme name x_scale: Scaling in X direction y_scale: Scaling in Y direction x_offset: Move in X direction y_offset: Move in Y direction

`eplan_import_dxfdwg_files`

eplan_import_dxfdwg_files(source_path: str, destination_path: str, project_name: str=None, import_scheme: str=None, macro_project: str=None, only_macro_project: bool=False, code_page: int=437)

Import DXF/DWG drawings as macros. The import is not made via the project, but the DXF/DWG files are directly imported from a directory into macros. Action: import

Args: source_path: Directory where DXF/DWG files are located destination_path: Directory where imported macros are stored project_name: Project path (optional) import_scheme: DXF/DWG import scheme name macro_project: Full path of new macro project (.elk) only_macro_project: Only create macro project without auto export code_page: Code page (default 437)

`eplan_import_pdf_comments`

eplan_import_pdf_comments(import_file: str, project_name: str)

Import PDF comments into project. Note: Some settings need to be configured before importing. Action: import

Args: import_file: Path to PDF file with comments project_name: Project path (required)

`eplan_import_3d`

eplan_import_3d(import_file: str, type: str, project_name: str=None, import_scheme: str=None)

Import 3D data. Action: import3d

Live-verified 2026-09-04 (2025.0.3, Pro Panel licensed): the previous wrapper never sent the mandatory TYPE and sent IMPORTSCHEME, which is not a real import3d parameter (the action documents SCHEME) - EPLAN answered every call with “Este proceso no es compatible.” and nothing was imported. See Audit #42 item 4.

Args: import_file: Path to the 3D file to import. type: “STEP”, “DESIGNSPACE” (a design space, itself a STEP file), or “JT”. Mandatory - the action has no default and silently rejects the call without it. project_name: Project path (optional). Required if there is no project with focus in the EPLAN GUI. import_scheme: Import scheme (optional). If omitted, the last-used scheme applies.

`eplan_create_labels`

eplan_create_labels(destination_file: str, project_name: str=None, config_scheme: str=None, filter_scheme: str=None, sort_scheme: str=None, language: str=None, record_repeat: int=None, task_repeat: int=None, show_output: bool=False, use_selection: bool=False)

Produce a formatted, template-driven output file from project data. Action: label

Despite the name this is EPLAN’s general labelling/reporting export, not only sticker labels: it is the right tool whenever the user wants a deliverable shaped by a scheme - a parts list they will print, a titled and sorted table, a device list for a shop. For the raw underlying parts data instead, use export_parts_list.

Args: destination_file: Output file (txt, xls, xlsx, xml) project_name: Project path (optional) config_scheme: Configuration scheme filter_scheme: Filter scheme sort_scheme: Sorting scheme language: Language code record_repeat: Repetitions per label task_repeat: Repetitions of total output show_output: Show output file after generation use_selection: Use current selection as input

`eplan_generate_macros`

eplan_generate_macros(project_name: str=None, destination_path: str=None, scheme: str=None)

Generate macros from project. Action: generatemacros

`eplan_prepare_macros`

eplan_prepare_macros(project_name: str=None)

Prepare project for macro generation. Action: preparemacros

`eplan_update_macros`

eplan_update_macros(project_path: str=None, scheme_name: str=None)

Update macros in project. Action: XGedUpdateMacroAction

Args: project_path: Full path of the project (parameter ProjectName). If the project is not open, the action opens and closes it automatically. If omitted, the selected object in GED is used. scheme_name: Concrete scheme to use (optional, parameter SchemeName). If not given, the last used scheme is used.

`eplan_export_settings`

eplan_export_settings(xml_file: str, node: str=None, project: str=None)

Export settings to an XML file. Action: XSettingsExport

Args: xml_file: Full name of the target XML file (parameter XMLFile). node: Path of a setting node, e.g. “USER”, “STATION”, “COMPANY”, “USER.DIALOGSETTINGS” (parameter node, without PROJECT). project: Project (must be open) for exporting project settings (parameter prj).

`eplan_import_settings`

eplan_import_settings(xml_file: str, node: str=None, project: str=None)

Import project-, station-, company- or user settings from an XML file. Action: XSettingsImport

Args: xml_file: Full name of the XML file (parameter XmlFile). If empty, a file selection dialog appears. node: Node of settings to import (parameter Node), e.g. “User.XSbGui.CustomSymbols”. project: Full name of the target project for project settings (parameter Project).

`eplan_set_setting`

eplan_set_setting(name: str, value: str, index: int=0)

Set the value of a setting. Action: XAfActionSetting

Args: name: Name of the setting to set (parameter set), e.g. “USER.MacrosLog.Pxf.writeDebugInfo”. value: New value of the setting (parameter value). index: Optional index of the setting (parameter index, default 0).

`eplan_set_project_setting`

eplan_set_project_setting(name: str, value: str, project: str=None, index: int=0)

Set the value of a project setting. Action: XAfActionSettingProject

Args: name: Name of the project setting to set (parameter set). value: New value of the setting (parameter value). project: Full name of the target project (parameter Project). When empty, the currently selected project is used. index: Optional index of the setting (parameter index, default 0).

`eplan_lock_unlock_all_objects`

eplan_lock_unlock_all_objects(raw_args: str=None)

NOT VERIFIED on the reference machine - read the block below before use. DEPRECATED. The official 2027 action index lists this action as “This action is deprecated. Allows to set project settings.” and its documentation page 404s, so no parameter table exists for it.

!!! NOT VERIFIED - the live behaviour of this wrapper could not be tested on the reference machine (EPLAN Electric P8 2027.0.1, 2026-09-02/03). Read this before relying on it. !!!

This one was tested, and IT DOES NOT WORK. Every call FAILED with: “Unable to gain access to the database” regardless of whether a project was open.

The cause is deprecation, not licensing - do not read the failure as a missing module. EPLAN’s own 2027 action index marks LockUnlockAllObjects as deprecated, and it has no documentation page. ActionManager.FindAction does resolve it (module Eplan.EplApi.CommandLineActionsNet), so the name still exists in the installation, but resolving only means the name is registered.

It is shipped here for completeness only. Prefer the documented settings wrappers set_setting / set_project_setting.

To verify: there is no known working invocation. If EPLAN ever documents this action, or a parameter set is found that avoids the database error, retest then.

What IS covered: the command-string construction (bare call, and the raw parameter tail appended verbatim) is exercised offline by tests/test_new_actions_offline.py. Only the live EPLAN behaviour is unverified - and live, it fails.

Action: LockUnlockAllObjects

Because the parameters are undocumented, none are invented here: pass any parameters you have determined out of band through raw_args, which is appended to the command line verbatim. Prefer the documented settings wrappers (set_setting / set_project_setting) over this action.

Args: raw_args: Raw parameter tail appended verbatim, e.g. ‘/KEY:value /OTHER:“value with spaces”’. Quote values containing spaces yourself. Omit for a bare “LockUnlockAllObjects” call.

`eplan_export_parts_list`

eplan_export_parts_list(export_file: str, project_name: str=None, format: str=None)

Export the project’s raw parts data, for re-import or external processing. Action: partslist

Not the tool for a formatted deliverable. If the user wants a parts list they will print, hand to a shop, or build from a template - a label sheet, a titled and sorted list, an .xls someone reads - use create_labels instead, which is template-driven and takes config/filter/sort schemes. This tool emits the underlying data.

Args: export_file: Output file path. project_name: Project path. Ask the user rather than reusing a path seen earlier in the conversation. format: Output format. NOTE: EPLAN’s own partslist action ignores CONFIGSCHEME on TYPE:EXPORT, so there is no scheme parameter here on purpose - if the user needs scheme-driven output, that is another signal they want create_labels.

`eplan_import_parts_list`

eplan_import_parts_list(import_file: str, project_name: str=None, format: str=None)

Import parts list into project. Action: partslist

`eplan_select_part`

eplan_select_part()

Start the part selection dialog. Action: XPamSelectPart

`eplan_set_parts_data_source`

eplan_set_parts_data_source(data_source: str)

Change the parts management database type. Action: XPartsSetDataSourceAction

`eplan_partsmanagement_export`

eplan_partsmanagement_export(export_file: str, format: str='XPamExportXml', part_numbers: List[str]=None, manufacturers: List[str]=None, constructions: List[str]=None, connection_patterns: List[str]=None, accessory_lists: List[str]=None, accessory_placements: List[str]=None, filter_scheme: str=None)

Export parts and other parts management items. Action: partsmanagementapi

Args: export_file: Output file path (extension added automatically) format: Export format - “XPamExportXml” (default), “IXPartsImportExportEdz” part_numbers: List of part numbers to export (use [“*”] for all) manufacturers: List of manufacturer long names constructions: List of construction names connection_patterns: List of terminal/connection pattern names accessory_lists: List of accessory list names accessory_placements: List of accessory placement names filter_scheme: Filter scheme name for filtering export

Example: partsmanagement_export( export_file=“C:/temp/parts.xml”, part_numbers=[“A-B.100-C09EJ01”, “A-B.140M-C-AFA11”], manufacturers=[“LAPP”, “Rittal”] )

`eplan_partsmanagement_import`

eplan_partsmanagement_import(import_file: str, format: str='XPamImportXml', mode: int=0, additional_language: bool=False, filter_scheme: str=None)

Import parts and other parts management items. Action: partsmanagementapi

Args: import_file: Path to import file format: Import format - “XPamImportXml” (default), “IXPartsImportExportEdz” mode: Import mode: 0 = Append new records only (default) 1 = Update existing records only 2 = Update existing records and append new ones 3 = Replace existing records and append new ones additional_language: If True, multi-language properties are updated with another language rather than replaced filter_scheme: Filter scheme for filtering import

Example: partsmanagement_import( import_file=“C:/temp/parts.xml”, mode=2 # Update and append )

`eplan_partsmanagement_export_by_properties`

eplan_partsmanagement_export_by_properties(export_type: str, export_file: str, properties: Dict[int, str], format: str='XPamExportXml')

Export parts management items by property values. Action: partsmanagementapi

Args: export_type: Type of export: - “EXPORTPARTS” - Export parts - “EXPORTMANUFACTURERS” - Export manufacturers - “EXPORTCONSTRUCTIONS” - Export constructions - “EXPORTCONNECTIONPATTERNS” - Export connection patterns - “EXPORTACCESSORYLISTS” - Export accessory lists - “EXPORTACCESSORYPLACEMENTS” - Export accessory placements export_file: Output file path properties: Dict of property_id -> value pairs e.g., {22024: “2”, 22007: “ABB”} format: Export format - “XPamExportXml” or “IXPartsImportExportEdz”

Example: # Export every part with variant ‘2’ or manufacturer ‘ABB’ partsmanagement_export_by_properties( export_type=“EXPORTPARTS”, export_file=“C:/temp/parts.xml”, properties={22024: “2”, 22007: “ABB”} )

# Export constructions with specific names
partsmanagement_export_by_properties(
    export_type="EXPORTCONSTRUCTIONS",
    export_file="C:/temp/constructions.xml",
    properties={22931: "FES.130642"}
)

`eplan_partsmanagement_export_all`

eplan_partsmanagement_export_all(export_file: str, format: str='XPamExportXml')

Export all parts. Action: partsmanagementapi

Args: export_file: Output file path format: Export format

Example: partsmanagement_export_all(“C:/temp/all_parts.edz”, format=“IXPartsImportExportEdz”)

`eplan_plc_export`

eplan_plc_export(destination_file: str, converter_id: str, project_name: str=None, configuration_project: str=None, language: str=None, overwrite: bool=False, format: str=None)

Export PLC bus data using the specified converter. Action: plcservice (TYPE=BUSDATAEXPORT)

Args: destination_file: Destination file for the export (parameter DESTINATIONFILE). converter_id: PLC data converter ID (parameter CONVERTERID), e.g. “PlcDcXMLExchangerSiemens”, “PlcDcAMLExchangerGeneral”, “PlcDcXMLExchangerSchneider”, etc. project_name: Project path (optional). configuration_project: Name of the PLC configuration data set to export. language: Language identifier (e.g. “en_US”, “de_DE”). overwrite: Overwrite the output file if it already exists. format: Export format (only for converters with multiple formats), e.g. “AutomationML AR APC V1.4.0”.

`eplan_plc_import`

eplan_plc_import(source_file: str, converter_id: str, project_name: str=None, language: str=None, import_match: int=None)

Import PLC bus data using the specified converter. Action: plcservice (TYPE=BUSDATAIMPORT)

Args: source_file: Source file for the import (parameter SOURCEFILE). converter_id: PLC data converter ID (parameter CONVERTERID). project_name: Project path (optional). language: Language identifier (e.g. “en_US”, “de_DE”). import_match: Matching options for PLC data import (parameter IMPORTMATCH): 0 = Match by internal object ids, 1 = Match by identifying names (may show a compare dialog), 2 = Don’t match (create new functions for all imported objects).

`eplan_export_connections`

eplan_export_connections(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False, include_graphical_connections: bool=False)

Export connections of a project (for external editing). Note: Provided for backward compatibility; prefer dc_export (XMActionDCCommonExport) for new implementations. Action: XMExportConnectionsAction

Args: destination: Target file (TXT, XLSX, XML; format per ConfigScheme extension) (parameter Destination). project_name: Project path (parameter ProjectName). config_scheme: Configuration scheme (parameter ConfigScheme). language: Language code, e.g. “en_US” (parameter Language). complete_project: Export all connections, not only selected ones. execution_mode: 0=Export, 1=Export and edit, 2=Edit and return. immediate_import: Auto-import after edit (only for execution_mode 2). include_graphical_connections: Include graphical connections.

`eplan_export_functions`

eplan_export_functions(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export functions of a project (for external editing). Note: Prefer dc_export (XMActionDCCommonExport) for new implementations. Action: XMExportFunctionAction

Args: destination: Target file (TXT, XLSX, XML) (parameter Destination). project_name: Project path (parameter ProjectName). config_scheme: Configuration scheme (parameter ConfigScheme). language: Language code (parameter Language). complete_project: Export all functions, not only selected ones. execution_mode: 0=Export, 1=Export and edit, 2=Edit and return. immediate_import: Auto-import after edit (only for execution_mode 2).

`eplan_export_pages`

eplan_export_pages(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export pages of a project (for external editing). Note: Prefer dc_export (XMActionDCCommonExport) for new implementations. Action: XMExportPagesAction

Args: destination: Target file (TXT, XLSX, XML) (parameter Destination). project_name: Project path (parameter ProjectName). config_scheme: Configuration scheme (parameter ConfigScheme). language: Language code (parameter Language). complete_project: Export all pages, not only selected ones. execution_mode: 0=Export, 1=Export and edit, 2=Edit and return. immediate_import: Auto-import after edit (only for execution_mode 2).

`eplan_dc_import`

eplan_dc_import(import_file: str, project_name: str=None, progress_title: str=None)

Import a data configuration file into an existing EPLAN project. This allows the properties of functions to be changed. Action: XMActionDCImport

Args: import_file: Path of the data configuration (.edc) file (parameter DataConfigurationFile). project_name: Project path (parameter ProjectLink). progress_title: Optional progress title (parameter ProgressTitle).

`eplan_dc_export`

eplan_dc_export(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export project data configuration for external editing. This is the recommended action for connections/functions/pages/etc. export. Action: XMActionDCCommonExport

Validated 2026-07-24 against EPLAN 2025 in a 467-project unattended batch (execution_mode=2, immediate_import=True, complete_project=True): 467/467 returned success with no manual interaction and no errors.

IMPORTANT — execution_mode=2 does NOT pause for manual editing here. Every action in this wrapper runs under QuietMode (QuietModes.ShowNoDialogs, see _base.py) so no EPLAN dialog can block an unattended call. Normally execution_mode=2 (“Edit and return”) opens the exported file (e.g. in Excel) and waits for a human to edit and close it before continuing/reimporting. Under QuietMode that interactive step is suppressed — the call returns almost immediately, and with immediate_import=True the exported data is reimported essentially unchanged (a no-op roundtrip), not a human-edited result. If you actually need a human to edit the data before reimport, this wrapper cannot provide that; use execution_mode=0 (plain export, no reimport) and handle editing/reimport as separate steps outside QuietMode.

A batch across many projects with immediate_import=True writes back into each project (even if effectively a no-op roundtrip) — treat it as a write operation requiring the same care as any other project mutation (backups, off-hours, etc.), not as a read-only export.

Args: destination: Target file (TXT, XLSX, XML; format per CONFIGSCHEME extension) (parameter DESTINATION). Must be unique per call when batching multiple projects. project_name: Project path (parameter PROJECTNAME). The action opens the referenced project internally; it does not need to already be open in the EPLAN GUI. config_scheme: Configuration scheme (parameter CONFIGSCHEME). If not set, a dialog asks for it — under QuietMode this likely hangs or fails silently instead. Always pass this explicitly. language: Language code, e.g. “en_US” or “??_??” for all (parameter LANGUAGE). complete_project: Export the whole project, not only selected objects. execution_mode: 0=Export, 1=Export and edit, 2=Edit and return (see QuietMode caveat above — mode 2 behaves like a roundtrip export+reimport under this wrapper, not a real interactive edit). immediate_import: Auto-import after edit (only for execution_mode 2).

`eplan_export_dc_article_data`

eplan_export_dc_article_data(destination: str, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export article data for external editing. Action: XMExportDCArticleDataAction

Args: destination: Target file (TXT, XLSX, XML based on scheme) config_scheme: Configuration scheme (dialog shown if not set) language: Language code (e.g., “en_US”) complete_project: Export whole database, not just selected objects execution_mode: 0=Export, 1=Export and edit, 2=Edit and return immediate_import: Auto-import after edit (only for mode 2)

`eplan_import_dc_article_data`

eplan_import_dc_article_data(import_file: str, show_import_messages: bool=None, import_mode: int=None, identify_by_name: bool=None, progress_title: str=None)

Import a data configuration (.edc) file into the article database. Action: XMImportDCArticleDataAction

The previous wrapper sent PROJECTNAME/IMPORTFILE, neither a real parameter of this action - it targets the ARTICLE DATABASE, not a project, and its file parameter is DATACONFIGURATIONFILE. Live-verified 2026-09-04: with the old parameters EPLAN logged “attempted to start the XMPxfArticleImportDialog dialog in batch mode” and returned success:false; with the corrected parameters AND show_import_messages= False it ran to completion instead. show_import_messages defaults to True in EPLAN itself (an info dialog), which is a strong candidate for the same block if left unset here - pass False for an unattended call. Audit #42 item 5.

Args: import_file: Path to the .edc data configuration file. show_import_messages: Show the info dialog with the added-part count (optional; EPLAN’s own default is True - see above). Pass False for an unattended call. import_mode: 0 = only create new objects, 1 = only update existing objects, 2 = create new and update objects (optional; if omitted, EPLAN may show a question dialog when new objects are found). identify_by_name: Identify objects by name instead of ID (optional; EPLAN’s default is by ID). progress_title: Title for the progress dialog (optional).

`eplan_export_location_boxes`

eplan_export_location_boxes(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export location boxes of a project. Note: Use dc_export (XMActionDCCommonExport) for new implementations. Action: XMExportLocationBoxesAction

Args: destination: Target file (TXT, XLS, XML) project_name: Project path (optional) config_scheme: Configuration scheme language: Language code complete_project: Export all pages, not just selected execution_mode: 0=Export, 1=Export and edit, 2=Edit and return immediate_import: Auto-import after edit (only for mode 2)

`eplan_export_potential_definitions`

eplan_export_potential_definitions(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export potential definitions of a project. Note: Use dc_export (XMActionDCCommonExport) for new implementations. Action: XMExportPotentialDefsAction

`eplan_export_pipeline_definitions`

eplan_export_pipeline_definitions(destination: str, project_name: str=None, config_scheme: str=None, language: str=None, complete_project: bool=False, execution_mode: int=0, immediate_import: bool=False)

Export pipeline definitions of a project. Action: XMExportPipeLineDefsAction

`eplan_delete_representation_type`

eplan_delete_representation_type(representation_type: int, source: str, destination: str)

Remove a representation type from macro files, written to a new location. Action: XMDeleteReprTypeAction

This is a macro-file utility, not a project action: the previous wrapper only sent PROJECTNAME, but the action’s real (and only) parameters are RepresentationType/Source/Destination - project_name never had anything to do with it. Audit #42 item 7.

EPLAN’s docs mark this action “can only be used interactively”, and that is confirmed, not theoretical: live-verified 2026-09-04 with correct parameters (a real macro as Source, an empty scratch directory as Destination) - the call returns success:true, logs no error, and Destination stays empty. Under this server’s forced QuietMode the action is a genuine no-op, not a wrapper bug. There is no known workaround; this is documented so a caller does not spend time debugging parameters that were never the problem.

Source is read from, not modified; the result is written under Destination (a directory), so the input macro(s) are left untouched.

Args: representation_type: Representation type to remove, 0-13: 0 Neutral, 1 MultiLine, 2 SingleLine, 3 PairCrossReference, 4 Overview, 5 Graphics, 6 ArticlePlacement, 7 PI_FlowChart, 8 Fluid_MultiLine, 9 Cabling, 10 ArticlePlacement3D, 11 Functional, 12 Planning, 13 FluidFunctionalOverview. source: A file, directory, or wildcard pattern selecting the macro(s) to process (e.g. “C:/macros/*.ema”). destination: Output directory the processed macro(s) are written to.

`eplan_correct_connections`

eplan_correct_connections()

Merge graphical properties of connection definition points. Action: EsCorrectConnections

`eplan_remove_unnecessary_ndps`

eplan_remove_unnecessary_ndps()

Remove unnecessary net definition points. Action: XCMRemoveUnnecessaryNDPsAction

`eplan_unite_net_definition_points`

eplan_unite_net_definition_points()

Unite net definition points on the same net. Action: XCMUniteNetDefinitionPointsAction

`eplan_export_subproject`

eplan_export_subproject(destination_path: str=None, project_name: str=None, subproject_number: str=None, extend_only: bool=None)

Export (split off) a subproject. Action: subprojects (TYPE=FILEOFF)

Note: The project must be opened in exclusive mode. After this action the source project object becomes invalid.

Args: destination_path: Target directory (parameter DESTINATIONPATH). Default is “$(MD_PROJECTS)”. project_name: Project path (parameter PROJECTNAME). subproject_number: Subproject number (parameter SPNR). extend_only: Extend subproject only (parameter EXTENDONLY).

`eplan_import_subproject`

eplan_import_subproject(project_name: str=None, subproject_number: str=None, subproject_dir: str=None)

Import (store back) a subproject. Action: subprojects (TYPE=STORE)

Note: The project must be opened in exclusive mode.

Args: project_name: Project path (parameter PROJECTNAME). subproject_number: Subproject number (parameter SPNR). subproject_dir: Directory where the subproject is placed (parameter SUBPROJECTDIR, STORE only). Default is taken from the alias.

`eplan_masterdata_operation`

eplan_masterdata_operation(operation_type: str, source_path: str=None, destination_path: str=None)

Perform master data operations. Action: masterdata

`eplan_export_nc_data`

eplan_export_nc_data(export_file: str, project_name: str=None)

Export NC data for machines. Action: ExportNCData

`eplan_export_production_wiring`

eplan_export_production_wiring(export_file: str, project_name: str=None)

Export production wiring data for machines. Action: ExportProductionWiring

`eplan_export_ribbon_bar`

eplan_export_ribbon_bar(export_file: str)

Export main ribbon bar customization to XML. Action: MfExportRibbonBarAction

Args: export_file: Path to the file to be created by the export (parameter FileName).

`eplan_import_ribbon_bar`

eplan_import_ribbon_bar(import_file: str)

Import main ribbon bar customization from XML. Action: MfImportRibbonBarAction

Args: import_file: Path to the ribbon bar file to import (parameter FileName).

This page is generated from the docstrings in Canary-ECAD/eplan-mcp.