ezdwg

https://monozukuri-ai.github.io/ezdwg/
Admin
Python library for reading DWG files (R14-R2018) with a high-performance Rust core, providing an...
Tokens:17,036
Snippets:203
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install ezdwg with DXF support

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Install the ezdwg library with the necessary dependencies for DXF conversion.

```bash
pip install "ezdwg[dxf]"
```

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

### Install ezdwg from PyPI

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/installation

Install the base ezdwg package using pip.

```bash
pip install ezdwg

```

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

### Install ezdwg from Source

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/installation

Build and install ezdwg from its source code. Requires a Rust toolchain and Python 3.10+.

```bash
git clone https://github.com/monozukuri-ai/ezdwg.git
cd ezdwg
maturin develop
pip install -e .

```

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

### Get ezdwg Version

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Check the installed version of the ezdwg CLI.

```bash
ezdwg --version

```

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

### Example Convert Output

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Shows the output details after a DWG to DXF conversion.

```text
input: input.dwg
output: output.dxf
total_entities: 15
written_entities: 12
skipped_entities: 3
skipped[VIEWPORT]: 3


```

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

### Install ezdwg with Both Plotting and DXF Dependencies

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/installation

Install ezdwg with both plotting and DXF conversion extras.

```bash
pip install "ezdwg[plot,dxf]"

```

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

### Install Plotting Extra

Source: https://monozukuri-ai.github.io/ezdwg/guide/plotting

Install the plotting extra for ezdwg to enable matplotlib rendering capabilities.

```bash
pip install "ezdwg[plot]"
```

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

### Install ezdwg with DXF Conversion Dependencies

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/installation

Install ezdwg with optional DWG to DXF conversion support using the ezdxf backend.

```bash
pip install "ezdwg[dxf]"

```

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

### Install ezdwg with Plotting Dependencies

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/installation

Install ezdwg with optional plotting support using matplotlib.

```bash
pip install "ezdwg[plot]"

```

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

### Example Inspect Output

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Illustrates the typical output format when inspecting a DWG file.

```text
file: examples/data/line_2000.dwg
version: AC1015
decode_version: AC1015
total_entities: 3
LINE: 3


```

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

### ezdwg CLI Usage Examples

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Demonstrates various command-line interface commands for ezdwg, including showing version, inspecting files, converting DWG to DXF, and writing DWG files with a specified version.

```bash
# Show version
ezdwg --version

# Inspect a DWG file
ezdwg inspect path/to/file.dwg

# Convert DWG to DXF
ezdwg convert input.dwg output.dxf

# Write DWG (native AC1015 writer)
ezdwg write input.dwg output.dwg --dwg-version AC1015

```

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

### Extracting Points from LINE Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/entity

Example of iterating through LINE entities and extracting their start and end points using the to_points() method.

```python
for entity in msp.query("LINE"):
    start, end = entity.to_points()
    print(f"Line from {start} to {end}")

```

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

### Example Write Output

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Details the output of the DWG writing process, including entity counts and skipped entities.

```text
input: input.dwg
output: output.dwg
target_version: AC1015
total_entities: 8
written_entities: 7
skipped_entities: 1
skipped[POINT]: 1


```

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

### EZDWG Usage Example: Version Detection and Entity Decoding

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Demonstrates how to use the `ezdwg.raw` module to detect the DWG version and decode LINE and ARC entities. Ensure the `ezdwg` library is imported.

```python
from ezdwg import raw

# Detect version
version = raw.detect_version("drawing.dwg")
print(f"Version: {version}")

# Decode lines
for handle, sx, sy, sz, ex, ey, ez in raw.decode_line_entities("drawing.dwg"):
    print(f"Line {handle}: ({sx},{sy},{sz}) -> ({ex},{ey},{ez})")

# Decode arcs (angles in radians!)
import math
for handle, cx, cy, cz, r, sa, ea in raw.decode_arc_entities("drawing.dwg"):
    print(f"Arc {handle}: center=({cx},{cy},{cz}) r={r} "
          f"angles={math.degrees(sa):.1f}°-{math.degrees(ea):.1f}°")
```

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

### Convert DWG to DXF

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Converts a DWG file to a DXF file using the `to_dxf` function. Requires the `dxf` extra to be installed. Reports the number of written and total entities.

```python
import ezdwg

result = ezdwg.to_dxf("input.dwg", "output.dxf")
print(f"Written: {result.written_entities}/{result.total_entities} entities")

```

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

### Access Modelspace

Source: https://monozukuri-ai.github.io/ezdwg/guide/reading-files

Get the modelspace from the Document object to access drawing entities. This returns a Layout object.

```python
msp = doc.modelspace()

```

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

### Plot DWG Document

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Plots the content of a DWG document to display it. Requires the `plot` extra to be installed.

```python
import ezdwg

doc = ezdwg.read("path/to/file.dwg")
doc.plot()

```

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

### raw.decode_line_entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes line entities from a DWG file, returning start and end points.

```APIDOC
## decode_line_entities

### Description
Each tuple: `(handle, start_x, start_y, start_z, end_x, end_y, end_z)`.

### Method
GET

### Endpoint
`/raw/decode_line_entities`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of line entities to decode.

### Response
#### Success Response (200)
- **lines** (list[tuple[int, float, float, float, float, float, float]]) - A list of tuples, where each tuple contains line entity data.
```

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

### Decode DWG Line Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes line entities from a DWG file. Each tuple contains the entity handle and its start and end coordinates (x, y, z). An optional limit can be applied.

```python
raw.decode_line_entities(path: str, limit: int | None = None) -> list[tuple[int, float, float, float, float, float, float]]
```

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

### Decode DWG Arc Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes arc entities from a DWG file. Each tuple contains the entity handle, center coordinates (x, y, z), radius, start angle, and end angle. Angles are in radians. An optional limit can be applied.

```python
raw.decode_arc_entities(path: str, limit: int | None = None) -> list[tuple[int, float, float, float, float, float, float]]
```

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

### Converting Entities to Points

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Shows how to use the `to_points()` method to extract key coordinates from various entity types like LINE, LWPOLYLINE, and POINT. This is essential for geometric processing.

```python
for entity in msp.query("LINE LWPOLYLINE POINT"):
    points = entity.to_points()
    print(entity.dxftype, points)

```

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

### Querying Entities by Multiple Type Names

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Demonstrates querying for multiple entity types simultaneously using a space-separated string. This allows for efficient retrieval of related entity types.

```python
msp = doc.modelspace()

# Multiple types (space-separated)
for entity in msp.query("LINE ARC CIRCLE"):
    print(entity.dxftype, entity.dxf)

```

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

### Querying All Entities in Model Space

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Demonstrates how to retrieve all supported entity types from the model space of a DXF document. Useful for iterating through all drawing objects.

```python
msp = doc.modelspace()

# All supported entity types
for entity in msp.query():
    print(entity.dxftype, entity.handle)

```

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

### Decode Ellipse Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes ELLIPSE entities from a DWG file. The returned tuple includes the handle, center, extrusion, major axis, ratio, start angle, and end angle.

```python
raw.decode_ellipse_entities(path: str, limit: int | None = None) -> list[tuple[int, ...]]
```

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

### Inspect DWG File Information

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Display basic information about a DWG file, including entity counts.

```bash
ezdwg inspect path/to/file.dwg

```

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

### Convert DWG to DXF from a File Path

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Perform a basic conversion of a DWG file to DXF format by providing input and output file paths.

```python
import ezdwg

result = ezdwg.to_dxf("input.dwg", "output.dxf")
print(f"Written: {result.written_entities}/{result.total_entities}")
```

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

### raw.list_object_headers

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers, including handle, offset, size, and type code.

```APIDOC
## list_object_headers

### Description
List object headers. Each tuple: `(handle, offset, size, type_code)`.

### Method
GET

### Endpoint
`/raw/list_object_headers`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of headers to return.

### Response
#### Success Response (200)
- **headers** (list[tuple[int, int, int, int]]) - A list of tuples, where each tuple contains the object handle, offset, size, and type code.
```

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

### Read a DWG File

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Opens a DWG file and accesses its model space. Requires the path to the DWG file.

```python
import ezdwg

doc = ezdwg.read("path/to/file.dwg")
print(f"Version: {doc.version}")

msp = doc.modelspace()

```

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

### Read DWG File

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Opens a DWG file and returns a Document object. Ensure the file path is correct and the DWG version is supported.

```python
import ezdwg

doc = ezdwg.read("drawing.dwg")
print(doc.version)
```

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

### Convert DWG to DXF

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Convert a DWG file to DXF format. Specify output DXF version and entity types to include.

```bash
ezdwg convert input.dwg output.dxf

```

```bash
# Convert with type filter
ezdwg convert input.dwg output.dxf --types "ARC LINE"

```

```bash
# Specify DXF version
ezdwg convert input.dwg output.dxf --dxf-version R2018

```

```bash
# Strict mode
ezdwg convert input.dwg output.dxf --strict

```

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

### Read DWG and Query Entities

Source: https://monozukuri-ai.github.io/ezdwg

This snippet demonstrates how to read a DWG file and query for specific entity types like LINE, ARC, and CIRCLE. It then iterates through the found entities and prints their type, handle, and DXF data.

```python
import ezdwg

doc = ezdwg.read("drawing.dwg")
msp = doc.modelspace()

for entity in msp.query("LINE ARC CIRCLE"):
    print(entity.dxftype, entity.handle, entity.dxf)

```

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

### Iterate Over All Entities

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Queries and iterates over all specified entity types within the model space. Prints the entity type, handle, and DXF data.

```python
for entity in msp.query("LINE LWPOLYLINE ARC CIRCLE ELLIPSE POINT TEXT MTEXT DIMENSION"):
    print(entity.dxftype, entity.handle, entity.dxf)

```

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

### Specify DXF Version for Conversion

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Convert a DWG file to DXF, explicitly setting the DXF version for compatibility.

```python
result = ezdwg.to_dxf(
    "input.dwg",
    "output.dxf",
    dxf_version="R2010",  # default
)
```

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

### Query Entities by Type

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Iterates over entities within a layout, with options to filter by specific DXF types.

```python
# All entities
for entity in msp.query():
    print(entity.dxftype)
```

```python
# Filter by type string
for line in msp.query("LINE"):
    print(line.dxf["start"])
```

```python
# Multiple types
for entity in msp.query("LINE ARC CIRCLE"):
    print(entity.dxftype, entity.handle)
```

```python
# From an iterable
for entity in msp.query(["LINE", "ARC"]):
    print(entity.dxftype)
```

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

### Plot Layout from Document

Source: https://monozukuri-ai.github.io/ezdwg/guide/plotting

Access a specific layout (e.g., model space) from a document object and plot its contents.

```python
msp = doc.modelspace()
msp.plot()
```

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

### Entity to_points Method Signature

Source: https://monozukuri-ai.github.io/ezdwg/api/entity

Provides the method signature for extracting key coordinate points from an entity. Raises NotImplementedError for unsupported types.

```python
Entity.to_points() -> list[tuple[float, float, float]]

```

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

### Access Document Properties

Source: https://monozukuri-ai.github.io/ezdwg/guide/reading-files

Retrieve the DWG version, decoded version, and file path from the Document object.

```python
doc = ezdwg.read("path/to/file.dwg")

print(doc.version)         # e.g. "AC1015"
print(doc.decode_version)  # e.g. "AC1015"
print(doc.path)            # file path

```

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

### ezdwg.read

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Opens a DWG file from the specified path and returns a Document object. It supports reading various DWG versions and raises a ValueError for unsupported versions.

```APIDOC
## ezdwg.read

### Description
Opens a DWG file and returns a `Document`.

### Method
`ezdwg.read(path: str) -> Document`

### Parameters
#### Path Parameters
- **path** (str) - Required - Path to the DWG file.

### Returns
- **Document** - A `Document` object representing the DWG file.

### Raises
- **ValueError** - If the DWG version is unsupported.

### Example
```python
import ezdwg

doc = ezdwg.read("drawing.dwg")
print(doc.version)
```
```

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

### Convert DWG to DXF from a Document Object

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Convert a loaded DWG document object to DXF format.

```python
doc = ezdwg.read("input.dwg")
result = doc.export_dxf("output.dxf")
```

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

### Entity Structure and Attributes

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Illustrates the basic structure of an ezdwg Entity object, including its type, handle, and DXF attributes dictionary. This is fundamental for understanding entity data.

```python
from ezdwg import Entity

# Entity fields:
entity.dxftype  # str — entity type name (e.g. "LINE", "ARC")
entity.handle   # int — unique handle within the file
entity.dxf      # dict[str, Any] — entity-specific attributes

```

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

### raw.list_object_headers_with_type

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers with resolved type names and type classes.

```APIDOC
## list_object_headers_with_type

### Description
List object headers with resolved type names. Each tuple: `(handle, offset, size, type_code, type_name, type_class)`.
`type_class` is `"E"` for entities and `"O"` for objects.

### Method
GET

### Endpoint
`/raw/list_object_headers_with_type`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of headers to return.

### Response
#### Success Response (200)
- **headers** (list[tuple[int, int, int, int, str, str]]) - A list of tuples containing object handle, offset, size, type code, type name, and type class.
```

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

### Raw API Functions

Source: https://monozukuri-ai.github.io/ezdwg/api

Provides low-level access to Rust decode functions for performance-critical operations.

```APIDOC
## Raw API

### Description
Provides direct access to low-level Rust decode functions. Returns data as tuples, useful for performance-critical code or accessing fields not exposed by the high-level API.

### Module
- `ezdwg.raw`: Contains low-level decode functions.

### Usage Notes
- The raw API returns ARC angles in radians.
```

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

### List DWG Object Headers with Type Names

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers with their resolved type names and classes. Each tuple includes handle, offset, size, type code, type name, and type class ('E' for entities, 'O' for objects). An optional limit can be applied.

```python
raw.list_object_headers_with_type(path: str, limit: int | None = None) -> list[tuple[int, int, int, int, str, str]]
```

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

### Filter Entities by Specific Types

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Demonstrates filtering entities by specific types, such as only lines or a combination of arcs and circles. Accesses specific DXF properties like start/end points or center/radius.

```python
# Only lines
for line in msp.query("LINE"):
    print(line.dxf["start"], "->", line.dxf["end"])

# Multiple types
for entity in msp.query("ARC CIRCLE"):
    print(entity.dxftype, entity.dxf["center"], entity.dxf["radius"])

```

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

### Convert DWG to DXF from a Layout

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Export a specific layout (e.g., model space) from a DWG document to DXF format.

```python
doc = ezdwg.read("input.dwg")
msp = doc.modelspace()
result = msp.export_dxf("output.dxf")
```

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

### Inspect DWG File with Verbose Diagnostics

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Show expanded diagnostic details when inspecting a DWG file, including more unknown handle/type-code entries.

```bash
ezdwg inspect path/to/file.dwg --verbose

```

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

### Layout.query

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Iterates over entities within a layout, with optional filtering by entity type.

```APIDOC
## Layout.query

### Description
Iterate over entities, optionally filtered by type.

### Method
Layout.query(types: str | Iterable[str] | None = None)

### Parameters
- **types** (str | Iterable[str] | None) - Optional - Space-separated type names (e.g. "LINE ARC"), an iterable of type names, or `None` for all types.

### Response
- **Iterator[Entity]**: An iterator yielding `Entity` objects.
```

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

### Document.modelspace

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Retrieves the modelspace layout from a Document object. This is the primary space for drawing entities.

```APIDOC
## Document.modelspace

### Description
Return the modelspace layout.

### Method
Document.modelspace()

### Parameters
None

### Response
- **Layout**: The modelspace layout object.
```

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

### raw.list_object_map_entries

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object map entries, providing the handle and offset for each entry.

```APIDOC
## list_object_map_entries

### Description
List object map entries. Each tuple: `(handle, offset)`.

### Method
GET

### Endpoint
`/raw/list_object_map_entries`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of entries to return.

### Response
#### Success Response (200)
- **entries** (list[tuple[int, int]]) - A list of tuples, where each tuple contains the object handle and its offset.
```

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

### Export Opened Document to Native DWG (AC1015)

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Exports an already opened DWG document to a DWG file, specifying the version as AC1015 using the `export_dwg` method.

```python
doc = ezdwg.read("input.dwg")
doc.export_dwg("output.dwg", version="AC1015")

```

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

### Querying Entities by Type Name

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Shows how to filter entities by their DXF type name, such as 'LINE'. This is useful for processing specific kinds of entities.

```python
msp = doc.modelspace()

# Filter by type name(s)
for entity in msp.query("LINE"):
    print(entity.dxf)

```

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

### Export Opened Document to DXF

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Exports an already opened DWG document to a DXF file using the `export_dxf` method.

```python
doc = ezdwg.read("input.dwg")
doc.export_dxf("output.dxf")

```

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

### Detect DWG Version

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Detects and returns the DWG version string of a given file path.

```python
raw.detect_version(path: str) -> str
```

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

### Document & Layout Classes

Source: https://monozukuri-ai.github.io/ezdwg/api

Classes for representing and manipulating DWG documents and their layouts.

```APIDOC
## Document & Layout Classes

### Description
Provides classes for representing and manipulating DWG documents and their layouts within the high-level API.

### Classes
- `Document`: Represents a DWG document.
- `Layout`: Represents a layout within a DWG document.
```

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

### Plot DWG from Document Object

Source: https://monozukuri-ai.github.io/ezdwg/guide/plotting

Read a DWG file into a document object and then plot it using the plot() method.

```python
import ezdwg

doc = ezdwg.read("drawing.dwg")
doc.plot()
```

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

### Core Functions

Source: https://monozukuri-ai.github.io/ezdwg/api

Provides core functions for reading, plotting, and converting DWG files. The high-level API is recommended for most use cases.

```APIDOC
## Core Functions

### Description
Provides core functions for reading, plotting, and converting DWG files. The high-level API is recommended for most use cases.

### Functions
- `ezdwg.read()`: Reads a DWG file.
- `ezdwg.plot()`: Plots a DWG file.
- `ezdwg.to_dxf()`: Converts a DWG file to DXF format.
- `ezdwg.to_dwg()`: Converts a file to DWG format.

### Usage Notes
- The high-level API returns ARC angles in degrees.
- The raw API returns angles in radians.
```

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

### raw.detect_version

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Detects the DWG version string of a given file path.

```APIDOC
## detect_version

### Description
Detect the DWG version string (e.g. `"AC1015"`).

### Method
GET

### Endpoint
`/raw/detect_version`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.

### Response
#### Success Response (200)
- **version** (str) - The DWG version string.
```

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

### Plot DWG Directly from File Path

Source: https://monozukuri-ai.github.io/ezdwg/guide/plotting

Plot a DWG file directly by providing its file path to the ezdwg.plot() function.

```python
import ezdwg

ezdwg.plot("drawing.dwg")
```

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

### List DWG Object Headers

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers from a DWG file, returning a list of (handle, offset, size, type_code) tuples. An optional limit can be applied.

```python
raw.list_object_headers(path: str, limit: int | None = None) -> list[tuple[int, int, int, int]]
```

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

### Open a DWG File

Source: https://monozukuri-ai.github.io/ezdwg/guide/reading-files

Use `ezdwg.read()` to open a DWG file. This function automatically detects the DWG version and returns a Document object. It raises a ValueError for unsupported versions.

```python
import ezdwg

doc = ezdwg.read("path/to/file.dwg")

```

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

### Export DWG Document to DWG using Native Writer

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Export a loaded DWG document object to a DWG file using the native writer.

```python
doc = ezdwg.read("input.dwg")
doc.export_dwg("output.dwg", version="AC1015")
```

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

### Save Plot to File

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Plots a DWG document and saves the output to a PNG file with specified DPI and bounding box settings. Requires `matplotlib` and the `plot` extra.

```python
import matplotlib.pyplot as plt

doc = ezdwg.read("path/to/file.dwg")
ax = doc.plot(show=False)
plt.savefig("output.png", dpi=150, bbox_inches="tight")

```

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

### List DWG Object Map Entries

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object map entries from a DWG file, returning a list of (handle, offset) tuples. An optional limit can be applied.

```python
raw.list_object_map_entries(path: str, limit: int | None = None) -> list[tuple[int, int]]
```

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

### Layout.export_dxf

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Exports the entities of a layout to a DXF file. Accepts keyword arguments compatible with ezdwg.to_dxf().

```APIDOC
## Layout.export_dxf

### Description
Export this layout to a DXF file.

### Method
Layout.export_dxf(output_path: str, **kwargs)

### Parameters
- **output_path** (str) - Required - The path to save the DXF file.
- **	exttt{**kwargs}**: Keyword arguments passed to `ezdwg.to_dxf()`.

### Response
- **ConvertResult**: Result of the DXF conversion.
```

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

### List DWG Section Locators

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists the locators for sections within a DWG file. Each locator is a tuple containing the section name, offset, and size.

```python
raw.list_section_locators(path: str) -> list[tuple[str, int, int]]
```

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

### Write DWG File

Source: https://monozukuri-ai.github.io/ezdwg/guide/cli

Write a DWG file using the native AC1015 writer. Supports filtering entity types and strict mode.

```bash
ezdwg write input.dwg output.dwg

```

```bash
# Write only selected entity types
ezdwg write input.dwg output.dwg --types "LINE MTEXT"

```

```bash
# Explicit target version
ezdwg write input.dwg output.dwg --dwg-version AC1015

```

```bash
# Strict mode
ezdwg write input.dwg output.dwg --strict

```

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

### Convert DWG to Native DWG (AC1015)

Source: https://monozukuri-ai.github.io/ezdwg/getting-started/quickstart

Converts a DWG file to another DWG file, specifying the version as AC1015 using the `to_dwg` function. Reports the number of written and total entities.

```python
import ezdwg

result = ezdwg.to_dwg("input.dwg", "output.dwg", version="AC1015")
print(f"Written: {result.written_entities}/{result.total_entities} entities")

```

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

### Enable Strict Mode for DWG to DXF Conversion

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Convert a DWG file to DXF in strict mode, which causes the conversion to fail if any entity cannot be written.

```python
result = ezdwg.to_dxf(
    "input.dwg",
    "output.dxf",
    strict=True,
)
```

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

### Write DWG File

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Writes a DWG file using the native writer, supporting various entity types. Allows specifying the output DWG version and operating in strict mode.

```python
import ezdwg

# Example usage (assuming source and output paths are defined)
# result = ezdwg.to_dwg(source="input.dwg", output_path="output.dwg", version="AC1015")
```

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

### raw.list_section_locators

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists section locators for a DWG file, returning their names, offsets, and sizes.

```APIDOC
## list_section_locators

### Description
List section locators. Each tuple: `(name, offset, size)`.

### Method
GET

### Endpoint
`/raw/list_section_locators`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.

### Response
#### Success Response (200)
- **locators** (list[tuple[str, int, int]]) - A list of tuples, where each tuple contains the section name, offset, and size.
```

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

### Filter Entities During DWG to DXF Conversion

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Convert a DWG file to DXF, specifying which entity types to include in the output.

```python
result = ezdwg.to_dxf(
    "input.dwg",
    "output.dxf",
    types="LINE ARC LWPOLYLINE",
)
```

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

### raw.list_object_headers_by_type

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers filtered by specified type codes.

```APIDOC
## list_object_headers_by_type

### Description
List object headers filtered by type codes. Each tuple: `(handle, offset, size, type_code, type_name, type_class)`.

### Method
GET

### Endpoint
`/raw/list_object_headers_by_type`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **type_codes** (list[int]) - Required - A list of integer type codes to filter by.
- **limit** (int | None) - Optional - Maximum number of headers to return.

### Response
#### Success Response (200)
- **headers** (list[tuple[int, int, int, int, str, str]]) - A list of tuples containing object headers filtered by type codes.
```

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

### Document.export_dxf

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Exports the modelspace of the document to a DXF file. Accepts keyword arguments compatible with ezdwg.to_dxf().

```APIDOC
## Document.export_dxf

### Description
Export the modelspace to a DXF file.

### Method
Document.export_dxf(output_path: str, **kwargs)

### Parameters
- **output_path** (str) - Required - The path to save the DXF file.
- **	exttt{**kwargs}**: Keyword arguments passed to `ezdwg.to_dxf()`.

### Response
- **ConvertResult**: Result of the DXF conversion.
```

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

### raw.read_object_records_by_handle

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Reads raw object records from a DWG file, specified by a list of handles.

```APIDOC
## read_object_records_by_handle

### Description
Read raw object records by handle. Each tuple: `(handle, offset, size, type_code, data)`.

### Method
GET

### Endpoint
`/raw/read_object_records_by_handle`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **handles** (list[int]) - Required - A list of integer handles to retrieve records for.
- **limit** (int | None) - Optional - Maximum number of records to return.

### Response
#### Success Response (200)
- **records** (list[tuple[int, int, int, int, bytes]]) - A list of tuples containing raw object records.
```

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

### Convert DWG to DXF

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Converts a DWG file to DXF format. Supports filtering entities by type and specifying the DXF version. Can operate in strict mode to fail on skipped entities.

```python
import ezdwg

# Example usage (assuming source and output paths are defined)
# result = ezdwg.to_dxf(source="input.dwg", output_path="output.dxf", types="LINE")
```

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

### Layout.iter_entities

Source: https://monozukuri-ai.github.io/ezdwg/api/document

An alias for the `query()` method, used to iterate over entities in a layout.

```APIDOC
## Layout.iter_entities

### Description
Alias for `query()`. Iterate over entities, optionally filtered by type.

### Method
Layout.iter_entities(types: str | Iterable[str] | None = None)

### Parameters
- **types** (str | Iterable[str] | None) - Optional - Space-separated type names (e.g. "LINE ARC"), an iterable of type names, or `None` for all types.

### Response
- **Iterator[Entity]**: An iterator yielding `Entity` objects.
```

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

### Convert DWG to DWG using Native Writer

Source: https://monozukuri-ai.github.io/ezdwg/guide/convert

Use the native DWG writer to convert a DWG file to another DWG file, specifying the version and entity types.

```python
import ezdwg

result = ezdwg.to_dwg(
    "input.dwg",
    "output.dwg",
    version="AC1015",
    types="LINE ARC CIRCLE LWPOLYLINE TEXT MTEXT",
)
print(result.written_entities, result.skipped_by_type)
```

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

### raw.decode_entity_styles

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes entity style information, including color and layer.

```APIDOC
## decode_entity_styles

### Description
Decode entity style information. Each tuple: `(handle, color_index, true_color, layer_handle)`.

### Method
GET

### Endpoint
`/raw/decode_entity_styles`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of styles to decode.

### Response
#### Success Response (200)
- **styles** (list[tuple[int, int | None, int | None, int]]) - A list of tuples containing entity style information.
```

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

### Layout Dataclass

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Represents a drawing layout, such as modelspace, and holds a reference to its Document.

```python
import ezdwg

@dataclass(frozen=True)
class Layout:
    doc: Document
    name: str
```

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

### Layout.export_dwg

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Exports the entities of a layout to a DWG file using the native writer. Accepts keyword arguments compatible with ezdwg.to_dwg().

```APIDOC
## Layout.export_dwg

### Description
Export this layout to a DWG file using the native writer.

### Method
Layout.export_dwg(output_path: str, **kwargs)

### Parameters
- **output_path** (str) - Required - The path to save the DWG file.
- **	exttt{**kwargs}**: Keyword arguments passed to `ezdwg.to_dwg()`.

### Response
- **WriteResult**: Result of the DWG write operation.
```

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

### ezdwg.to_dwg

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Writes a DWG file using the native writer, converting from a source file, Document, or Layout. Allows specifying the output path, entity types, and DWG version.

```APIDOC
## ezdwg.to_dwg

### Description
Write a DWG file using the native writer.

### Method
`ezdwg.to_dwg(
    source: str | Document | Layout,
    output_path: str,
    *, 
    types: str | Iterable[str] | None = None,
    version: str = "AC1015",
    strict: bool = False,
) -> WriteResult`

### Parameters
#### Path Parameters
- **source** (str | Document | Layout) - Required - File path, Document, or Layout to write.
- **output_path** (str) - Required - Output DWG file path.
- **types** (str | Iterable[str] | None) - Optional - Entity type filter.
- **version** (str) - Optional - Output DWG version (currently AC1015 only, default: "AC1015").
- **strict** (bool) - Optional - Fail on skipped entities (default: False).

### Returns
- **WriteResult** - A `WriteResult` object containing write details.

### Raises
- **ValueError** - When an unsupported write version is requested, or in strict mode if entities are skipped.

### Supported native write entities (v1):
  * `LINE`
  * `RAY`
  * `XLINE`
  * `POINT`
  * `ARC`
  * `CIRCLE`
  * `LWPOLYLINE`
  * `TEXT`
  * `MTEXT`
```

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

### Document.export_dwg

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Exports the modelspace of the document to a DWG file using the native writer. Accepts keyword arguments compatible with ezdwg.to_dwg().

```APIDOC
## Document.export_dwg

### Description
Export the modelspace to a DWG file using the native writer.

### Method
Document.export_dwg(output_path: str, **kwargs)

### Parameters
- **output_path** (str) - Required - The path to save the DWG file.
- **	exttt{**kwargs}**: Keyword arguments passed to `ezdwg.to_dwg()`.

### Response
- **WriteResult**: Result of the DWG write operation.
```

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

### List DWG Object Headers by Type Codes

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Lists object headers from a DWG file, filtered by specified type codes. An optional limit can be applied.

```python
raw.list_object_headers_by_type(path: str, type_codes: list[int], limit: int | None = None) -> list[tuple[int, int, int, int, str, str]]
```

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

### Entity.to_points()

Source: https://monozukuri-ai.github.io/ezdwg/api/entity

Extracts key coordinate points from a DXF entity. The specific points returned depend on the entity type.

```APIDOC
## Entity.to_points()

### Description
Extract key coordinate points from the entity. The method returns a list of 3D points, with the exact points varying based on the entity type.

### Method
`Entity.to_points()`

### Parameters
None

### Returns
`list[tuple[float, float, float]]` - A list of 3D points.

### Raises
`NotImplementedError` - For entity types that do not support this method.

### Supported Entity Types and Points Returned
- **LINE**: `[start, end]`
- **LWPOLYLINE**: All vertex points
- **POINT**: `[location]`
- **TEXT**: `[insert]`
- **MTEXT**: `[insert]`
- **DIMENSION**: `[defpoint2, defpoint3]` or `[text_midpoint]`
- **RAY**: `[start, start + unit_vector]`
- **XLINE**: `[start - unit_vector, start + unit_vector]`

### Example
```python
for entity in msp.query("LINE"):
    start, end = entity.to_points()
    print(f"Line from {start} to {end}")
```
```

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

### Document Dataclass

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Defines the structure for a DWG document, including its path and version.

```python
import ezdwg

@dataclass(frozen=True)
class Document:
    path: str
    version: str
    decode_path: str | None = None
    decode_version: str | None = None
```

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

### Read DWG Object Records by Handle

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Reads raw object records from a DWG file based on provided handles. Returns a list of tuples, each containing handle, offset, size, type code, and raw data. An optional limit can be applied.

```python
raw.read_object_records_by_handle(path: str, handles: list[int], limit: int | None = None) -> list[tuple[int, int, int, int, bytes]]
```

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

### Save Plot to File

Source: https://monozukuri-ai.github.io/ezdwg/guide/plotting

Plot a DWG document without displaying it immediately, then use matplotlib to save the plot to a file. Ensure `show=False` is set in the plot function.

```python
import matplotlib.pyplot as plt
import ezdwg

doc = ezdwg.read("drawing.dwg")
ax = doc.plot(show=False)
plt.savefig("output.png", dpi=150, bbox_inches="tight")
```

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

### raw.decode_object_handle_stream_refs

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes handle-stream references for specified objects in a DWG file.

```APIDOC
## decode_object_handle_stream_refs

### Description
Decode handle-stream references for objects. Each tuple: `(handle, ref_handles)`.

### Method
GET

### Endpoint
`/raw/decode_object_handle_stream_refs`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **handles** (list[int]) - Required - A list of integer handles to decode references for.
- **limit** (int | None) - Optional - Maximum number of references to decode.

### Response
#### Success Response (200)
- **references** (list[tuple[int, list[int]]]) - A list of tuples, where each tuple contains an object handle and its list of referenced handles.
```

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

### raw.decode_document_graph

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes a compact graph-oriented IR from a DWG file, returning detailed document information.

```APIDOC
## decode_document_graph

### Description
Decode a compact graph-oriented IR. The returned tuple contains:
  * DWG version string.
  * Object headers with resolved type names.
  * Common entity data: `(handle, type_name, owner_handle, color_index, true_color, layer_handle, linetype_handle, material_handle, plotstyle_handle, extension_dict_handle, reactor_handles)`.
  * Object graph edges: `(source_handle, kind, target_handle)`.
  * Layer table rows: `(handle, name, color_index, true_color)`.
  * Block header table rows: `(handle, name)`.
  * Header handle rows such as `("model_space_block_header", handle)`, current table handles such as `("clayer", handle)`, dictionaries, and table control handles such as `("layer_control", handle)`.

When `limit` is provided, object rows are truncated first and graph rows are limited to those object handles.

### Method
GET

### Endpoint
`/raw/decode_document_graph`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Limits the number of decoded rows.

### Response
#### Success Response (200)
- **document_data** (tuple) - A tuple containing DWG version, object headers, entity data, graph edges, layer table rows, block header table rows, and header handle rows.
```

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

### Decode DWG Entity Styles

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes entity style information from a DWG file, including handle, color index, true color, and layer handle. An optional limit can be applied.

```python
raw.decode_entity_styles(path: str, limit: int | None = None) -> list[tuple[int, int | None, int | None, int]]
```

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

### Using iter_entities Alias for Querying

Source: https://monozukuri-ai.github.io/ezdwg/guide/entities

Illustrates that `iter_entities()` is an alias for `query()`, providing an alternative way to iterate over entities filtered by type. Use this for consistency if preferred.

```python
msp = doc.modelspace()

for entity in msp.iter_entities("LINE"):
    print(entity.dxf)

```

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

### ezdwg.to_dxf

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Converts a DWG file or Document object to DXF format and saves it to the specified output path. Supports filtering entities by type and specifying the DXF version.

```APIDOC
## ezdwg.to_dxf

### Description
Convert a DWG file to DXF format.

### Method
`ezdwg.to_dxf(
    source: str | Document | Layout,
    output_path: str,
    *, 
    types: str | Iterable[str] | None = None,
    dxf_version: str = "R2010",
    strict: bool = False,
    include_unsupported: bool = False,
) -> ConvertResult`

### Parameters
#### Path Parameters
- **source** (str | Document | Layout) - Required - File path, Document, or Layout to convert.
- **output_path** (str) - Required - Output DXF file path.
- **types** (str | Iterable[str] | None) - Optional - Entity type filter.
- **dxf_version** (str) - Optional - DXF version string (default: "R2010").
- **strict** (bool) - Optional - Fail on skipped entities (default: False).
- **include_unsupported** (bool) - Optional - Query unsupported types (default: False).

### Returns
- **ConvertResult** - A `ConvertResult` object containing conversion details.

### Raises
- **ValueError** - In strict mode if entities are skipped.
- **ImportError** - If ezdxf is not installed.
```

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

### ConvertResult Data Structure

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Represents the result of a DWG to DXF conversion, detailing paths, entity counts, and skipped entities by type.

```python
@dataclass(frozen=True)
class ConvertResult:
    source_path: str
    output_path: str
    total_entities: int
    written_entities: int
    skipped_entities: int
    skipped_by_type: dict[str, int]
```

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

### Decode Insert Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes INSERT entities (block references) from a DWG file. The output tuple includes the handle, insertion point, scale factors, rotation, and block name.

```python
raw.decode_insert_entities(path: str, limit: int | None = None) -> list[tuple[int, float, float, float, float, float, float, float, str | None]]
```

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

### Read DWG Object Records by Type

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Reads raw object records from a DWG file based on provided type codes. Returns a list of tuples, each containing handle, offset, size, type code, and raw data. An optional limit can be applied.

```python
raw.read_object_records_by_type(path: str, type_codes: list[int], limit: int | None = None) -> list[tuple[int, int, int, int, bytes]]
```

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

### Entity Dataclass

Source: https://monozukuri-ai.github.io/ezdwg/api

Represents individual entities within a DWG file using a dataclass structure.

```APIDOC
## Entity Dataclass

### Description
Represents individual entities within a DWG file using a dataclass structure in the high-level API.

### Class
- `Entity`: A dataclass representing an entity.
```

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

### raw.decode_layer_colors

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes layer color information from a DWG file.

```APIDOC
## decode_layer_colors

### Description
Decode layer color information. Each tuple: `(handle, color_index, true_color)`.

### Method
GET

### Endpoint
`/raw/decode_layer_colors`

### Parameters
#### Query Parameters
- **path** (str) - Required - Path to the DWG file.
- **limit** (int | None) - Optional - Maximum number of layer colors to decode.

### Response
#### Success Response (200)
- **layer_colors** (list[tuple[int, int, int | None]]) - A list of tuples containing layer color information.
```

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

### Entity Dataclass Definition

Source: https://monozukuri-ai.github.io/ezdwg/api/entity

Defines the structure of an Entity object, including its type, handle, and DXF attributes.

```python
from dataclasses import dataclass
from typing import Any

@dataclass(frozen=True)
class Entity:
    dxftype: str
    handle: int
    dxf: dict[str, Any]

```

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

### WriteResult Data Structure

Source: https://monozukuri-ai.github.io/ezdwg/api/core

Represents the result of a DWG write operation, including paths, target version, entity counts, and skipped entities.

```python
@dataclass(frozen=True)
class WriteResult:
    source_path: str
    output_path: str
    target_version: str
    total_entities: int
    written_entities: int
    skipped_entities: int
    skipped_by_type: dict[str, int]
```

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

### Document.plot

Source: https://monozukuri-ai.github.io/ezdwg/api/document

Plots all entities within the modelspace of the document. Accepts parameters compatible with ezdwg.plot().

```APIDOC
## Document.plot

### Description
Plot all entities in the modelspace.

### Method
Document.plot(*args, **kwargs)

### Parameters
- **	exttt{*args}**: Positional arguments passed to `ezdwg.plot()`.
- **	exttt{**kwargs}**: Keyword arguments passed to `ezdwg.plot()`.

### Response
- **Axes**: Plotting axes object.
```

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

### Decode Point Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes POINT entities from a DWG file. Each decoded entity is returned as a tuple containing its handle, coordinates (x, y, z), and thickness.

```python
raw.decode_point_entities(path: str, limit: int | None = None) -> list[tuple[int, float, float, float, float]]
```

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

### Decode Text Entities

Source: https://monozukuri-ai.github.io/ezdwg/api/raw

Decodes TEXT entities from a DWG file, including text content, insertion point, alignment, and style information.

```python
raw.decode_text_entities(path: str, limit: int | None = None) -> list[tuple[int, str, ...]]
```
Tokens:
Raw