Skip to content

fs_coordinate_format

fs_coordinate_format

Coordinate format token.

CoordinateFormat

Bases: ExtendedCommandToken

Description of coordinate format token.

See: - section 4.1.1 of The Gerber Layer Format Specification Revision 2023.03 - https://argmaster.github.io/pygerber/latest/gerber_specification/revision_2023_03.html - section 4.2.2 of The Gerber Layer Format Specification Revision 2023.03 - https://argmaster.github.io/pygerber/latest/gerber_specification/revision_2023_03.html

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
class CoordinateFormat(ExtendedCommandToken):
    """Description of coordinate format token.

    See:
    -   section 4.1.1 of The Gerber Layer Format Specification Revision 2023.03 - https://argmaster.github.io/pygerber/latest/gerber_specification/revision_2023_03.html
    -   section 4.2.2 of The Gerber Layer Format Specification Revision 2023.03 - https://argmaster.github.io/pygerber/latest/gerber_specification/revision_2023_03.html
    """

    def __init__(
        self,
        string: str,
        location: int,
        zeros_mode: TrailingZerosMode,
        coordinate_mode: CoordinateMode,
        x_format: AxisFormat,
        y_format: AxisFormat,
    ) -> None:
        super().__init__(string, location)
        self.zeros_mode = zeros_mode
        self.coordinate_mode = coordinate_mode
        self.x_format = x_format
        self.y_format = y_format

    @classmethod
    def new(cls, string: str, location: int, tokens: ParseResults) -> Self:
        """Create instance of this class.

        Created to be used as callback in `ParserElement.set_parse_action()`.
        """
        zeros_mode = TrailingZerosMode(tokens["zeros_mode"])
        coordinate_mode = CoordinateMode(tokens["coordinate_mode"])
        x_format = AxisFormat(
            integer=int(str(tokens["x_format"][0])),
            decimal=int(str(tokens["x_format"][1])),
        )
        y_format = AxisFormat(
            integer=int(str(tokens["y_format"][0])),
            decimal=int(str(tokens["y_format"][1])),
        )
        return cls(
            string=string,
            location=location,
            zeros_mode=zeros_mode,
            coordinate_mode=coordinate_mode,
            x_format=x_format,
            y_format=y_format,
        )

    def update_drawing_state(
        self,
        state: State,
        _backend: Backend,
    ) -> Tuple[State, Iterable[DrawCommand]]:
        """Set coordinate parser."""
        if state.coordinate_parser is not None:
            logging.warning(
                "Overriding coordinate format is illegal."
                "(See 4.2.2 in Gerber Layer Format Specification)",
            )
        return (
            state.model_copy(
                update={
                    "coordinate_parser": CoordinateParser.new(
                        x_format=self.x_format,
                        y_format=self.y_format,
                    ),
                },
            ),
            (),
        )

    def parser2_visit_token(self, context: Parser2Context) -> None:
        """Perform actions on the context implicated by this token."""
        context.get_hooks().coordinate_format.pre_parser_visit_token(self, context)
        context.get_hooks().coordinate_format.on_parser_visit_token(self, context)
        context.get_hooks().coordinate_format.post_parser_visit_token(self, context)

    def get_gerber_code(
        self,
        indent: str = "",
        endline: str = "\n",
    ) -> str:
        """Get gerber code represented by this token."""
        return (
            f"FS"
            f"{self.zeros_mode.get_gerber_code(indent, endline)}"
            f"{self.coordinate_mode.get_gerber_code(indent, endline)}"
            f"X{self.x_format.get_gerber_code(indent, endline)}"
            f"Y{self.y_format.get_gerber_code(indent, endline)}"
        )

new classmethod 

new(
    string: str, location: int, tokens: ParseResults
) -> Self

Create instance of this class.

Created to be used as callback in ParserElement.set_parse_action().

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
@classmethod
def new(cls, string: str, location: int, tokens: ParseResults) -> Self:
    """Create instance of this class.

    Created to be used as callback in `ParserElement.set_parse_action()`.
    """
    zeros_mode = TrailingZerosMode(tokens["zeros_mode"])
    coordinate_mode = CoordinateMode(tokens["coordinate_mode"])
    x_format = AxisFormat(
        integer=int(str(tokens["x_format"][0])),
        decimal=int(str(tokens["x_format"][1])),
    )
    y_format = AxisFormat(
        integer=int(str(tokens["y_format"][0])),
        decimal=int(str(tokens["y_format"][1])),
    )
    return cls(
        string=string,
        location=location,
        zeros_mode=zeros_mode,
        coordinate_mode=coordinate_mode,
        x_format=x_format,
        y_format=y_format,
    )

update_drawing_state 

update_drawing_state(
    state: State, _backend: Backend
) -> Tuple[State, Iterable[DrawCommand]]

Set coordinate parser.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
def update_drawing_state(
    self,
    state: State,
    _backend: Backend,
) -> Tuple[State, Iterable[DrawCommand]]:
    """Set coordinate parser."""
    if state.coordinate_parser is not None:
        logging.warning(
            "Overriding coordinate format is illegal."
            "(See 4.2.2 in Gerber Layer Format Specification)",
        )
    return (
        state.model_copy(
            update={
                "coordinate_parser": CoordinateParser.new(
                    x_format=self.x_format,
                    y_format=self.y_format,
                ),
            },
        ),
        (),
    )

parser2_visit_token 

parser2_visit_token(context: Parser2Context) -> None

Perform actions on the context implicated by this token.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
112
113
114
115
116
def parser2_visit_token(self, context: Parser2Context) -> None:
    """Perform actions on the context implicated by this token."""
    context.get_hooks().coordinate_format.pre_parser_visit_token(self, context)
    context.get_hooks().coordinate_format.on_parser_visit_token(self, context)
    context.get_hooks().coordinate_format.post_parser_visit_token(self, context)

get_gerber_code 

get_gerber_code(
    indent: str = "", endline: str = "\n"
) -> str

Get gerber code represented by this token.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
def get_gerber_code(
    self,
    indent: str = "",
    endline: str = "\n",
) -> str:
    """Get gerber code represented by this token."""
    return (
        f"FS"
        f"{self.zeros_mode.get_gerber_code(indent, endline)}"
        f"{self.coordinate_mode.get_gerber_code(indent, endline)}"
        f"X{self.x_format.get_gerber_code(indent, endline)}"
        f"Y{self.y_format.get_gerber_code(indent, endline)}"
    )

TrailingZerosMode

Bases: GerberCodeEnum

Coordinate format mode.

GerberX3 supports only one, L, the other is required for backwards compatibility.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
133
134
135
136
137
138
139
140
class TrailingZerosMode(GerberCodeEnum):
    """Coordinate format mode.

    GerberX3 supports only one, L, the other is required for backwards compatibility.
    """

    OmitLeading = "L"
    OmitTrailing = "T"

CoordinateMode

Bases: GerberCodeEnum

Coordinate format mode.

GerberX3 supports only one, A, the other required for backwards compatibility.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
143
144
145
146
147
148
149
150
class CoordinateMode(GerberCodeEnum):
    """Coordinate format mode.

    GerberX3 supports only one, A, the other required for backwards compatibility.
    """

    Absolute = "A"
    Incremental = "I"

AxisFormat

Bases: FrozenGeneralModel, GerberCode

Wrapper for single axis format.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class AxisFormat(FrozenGeneralModel, GerberCode):
    """Wrapper for single axis format."""

    integer: int
    decimal: int

    @property
    def total_length(self) -> int:
        """Total format length."""
        return self.integer + self.decimal

    def __str__(self) -> str:
        return f"{self.integer}{self.decimal}"

    def get_gerber_code(
        self,
        indent: str = "",
        endline: str = "\n",  # noqa: ARG002
    ) -> str:
        """Get gerber code represented by this token."""
        return f"{indent}{self.integer}{self.decimal}"

total_length property 

total_length: int

Total format length.

get_gerber_code 

get_gerber_code(
    indent: str = "", endline: str = "\n"
) -> str

Get gerber code represented by this token.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
167
168
169
170
171
172
173
def get_gerber_code(
    self,
    indent: str = "",
    endline: str = "\n",  # noqa: ARG002
) -> str:
    """Get gerber code represented by this token."""
    return f"{indent}{self.integer}{self.decimal}"

CoordinateParser

Bases: FrozenGeneralModel

Coordinate Parser class.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
class CoordinateParser(FrozenGeneralModel):
    """Coordinate Parser class."""

    x_format: AxisFormat
    y_format: AxisFormat

    @classmethod
    def new(
        cls,
        x_format: AxisFormat,
        y_format: AxisFormat,
        coordinate_mode: CoordinateMode = CoordinateMode.Absolute,
        zeros_mode: TrailingZerosMode = TrailingZerosMode.OmitLeading,
    ) -> Self:
        """Update coordinate parser format configuration."""
        if coordinate_mode != CoordinateMode.Absolute:
            raise IncrementalCoordinatesNotSupportedError

        if zeros_mode != TrailingZerosMode.OmitLeading:
            raise ZeroOmissionNotSupportedError

        for axis, axis_format in (("X", x_format), ("Y", y_format)):
            if axis_format.decimal < RECOMMENDED_MINIMAL_DECIMAL_PLACES:
                logging.warning(
                    "It is recommended to use at least 5 decimal places for coordinate "
                    "data when using metric units and 6 decimal places for imperial "
                    "units. (Detected for %s)"
                    "(See 4.2.2 in Gerber Layer Format Specification)",
                    axis,
                )

        return cls(x_format=x_format, y_format=y_format)

    def parse(self, coordinate: Coordinate) -> Decimal:
        """Parse raw coordinate data."""
        if coordinate.coordinate_type in (CoordinateType.X, CoordinateType.I):
            return self._parse(self.x_format, coordinate.offset, coordinate.sign)

        if coordinate.coordinate_type in (CoordinateType.Y, CoordinateType.J):
            return self._parse(self.y_format, coordinate.offset, coordinate.sign)

        raise UnsupportedCoordinateTypeError(coordinate.coordinate_type)

    def _parse(
        self,
        axis_format: AxisFormat,
        offset: str,
        sign: CoordinateSign,
    ) -> Decimal:
        total_length = axis_format.total_length

        if len(offset) > total_length:
            msg = f"Got {offset!r} with length {len(offset)} expected {total_length}."
            raise InvalidCoordinateLengthError(msg)

        offset = offset.rjust(axis_format.total_length, "0")
        integer, decimal = offset[: axis_format.integer], offset[axis_format.integer :]

        return Decimal(f"{sign.value}{integer}.{decimal}")

new classmethod 

new(
    x_format: AxisFormat,
    y_format: AxisFormat,
    coordinate_mode: CoordinateMode = CoordinateMode.Absolute,
    zeros_mode: TrailingZerosMode = TrailingZerosMode.OmitLeading,
) -> Self

Update coordinate parser format configuration.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
@classmethod
def new(
    cls,
    x_format: AxisFormat,
    y_format: AxisFormat,
    coordinate_mode: CoordinateMode = CoordinateMode.Absolute,
    zeros_mode: TrailingZerosMode = TrailingZerosMode.OmitLeading,
) -> Self:
    """Update coordinate parser format configuration."""
    if coordinate_mode != CoordinateMode.Absolute:
        raise IncrementalCoordinatesNotSupportedError

    if zeros_mode != TrailingZerosMode.OmitLeading:
        raise ZeroOmissionNotSupportedError

    for axis, axis_format in (("X", x_format), ("Y", y_format)):
        if axis_format.decimal < RECOMMENDED_MINIMAL_DECIMAL_PLACES:
            logging.warning(
                "It is recommended to use at least 5 decimal places for coordinate "
                "data when using metric units and 6 decimal places for imperial "
                "units. (Detected for %s)"
                "(See 4.2.2 in Gerber Layer Format Specification)",
                axis,
            )

    return cls(x_format=x_format, y_format=y_format)

parse 

parse(coordinate: Coordinate) -> Decimal

Parse raw coordinate data.

Source code in src/pygerber/gerberx3/tokenizer/tokens/fs_coordinate_format.py 
209
210
211
212
213
214
215
216
217
def parse(self, coordinate: Coordinate) -> Decimal:
    """Parse raw coordinate data."""
    if coordinate.coordinate_type in (CoordinateType.X, CoordinateType.I):
        return self._parse(self.x_format, coordinate.offset, coordinate.sign)

    if coordinate.coordinate_type in (CoordinateType.Y, CoordinateType.J):
        return self._parse(self.y_format, coordinate.offset, coordinate.sign)

    raise UnsupportedCoordinateTypeError(coordinate.coordinate_type)