partlib

1) """
2) Types representing entities of GNU PCB files.
3) """
4) 
5) import collections
6) 
7) 

8) class Coordinate():
9)     """
10)     A coordinate in a PCB file.
11)     """
12) 
13)     MIL = 1e2
14)     MM = 1e5 / 25.4
15) 
16)     def __init__(self, raw: float = 0):
17)         self._raw = round(raw)
18) 
19)     def __repr__(self) -> str:
20)         return f'Coordinate({self._raw:d})'
21) 
22)     def _compare(self, other) -> int:
23)         if not isinstance(other, Coordinate):
24)             raise ValueError(f'{type(self).__name__:s} cannot be'
25)                              f' compared to {type(other).__name__:s}')
26)         if self._raw < other._raw:
27)             return -1
28)         if self._raw > other._raw:
29)             return 1
30)         return 0
31) 
32)     def __eq__(self, other) -> bool:
33)         return self._compare(other) == 0
34) 
35)     def __ne__(self, other) -> bool:
36)         return self._compare(other) != 0
37) 
38)     def __lt__(self, other) -> bool:
39)         return self._compare(other) < 0
40) 
41)     def __le__(self, other) -> bool:
42)         return self._compare(other) <= 0
43) 
44)     def __gt__(self, other) -> bool:
45)         return self._compare(other) > 0
46) 
47)     def __ge__(self, other) -> bool:
48)         return self._compare(other) >= 0
49) 

50)     def __add__(self, other):
51)         assert isinstance(other, Coordinate)
52)         return Coordinate(self._raw + other._raw)
53) 
54)     def __mul__(self, other):
55)         return Coordinate(self._raw * other)
56) 
57)     def __neg__(self):
58)         return Coordinate(-self._raw)
59) 
60)     def __sub__(self, other):
61)         assert isinstance(other, Coordinate)
62)         return Coordinate(self._raw - other._raw)
63) 
64)     def __truediv__(self, other):
65)         return Coordinate(self._raw / other)
66) 

67)     @property
68)     def mil(self) -> float:
69)         return self._raw / self.MIL
70) 
71)     @mil.setter
72)     def mil(self, mil: float):
73)         self._raw = round(mil * self.MIL)
74) 
75)     @property
76)     def mm(self) -> float:
77)         return self._raw / self.MM
78) 
79)     @mm.setter
80)     def mm(self, mm: float):
81)         self._raw = round(mm * self.MM)
82) 
83)     @property
84)     def raw(self) -> int:
85)         return self._raw
86) 
87)     @raw.setter
88)     def raw(self, raw: float):
89)         self._raw = round(raw)
90) 
91) 

92) class Struct:
93)     """
94)     Base class for struct-like Python objects
95)     """
96) 
97)     _attrs = collections.OrderedDict()  # attribute name: str -> default value
98) 
99)     def __init__(self, **kwargs):
100)         for name, def_val in self._attrs.items():
101)             setattr(self, name, def_val)
102)         for name, val in kwargs.items():
103)             if name not in self._attrs:
104)                 raise ValueError(
105)                     f'{type(self).__name__:s} does not have attribute {name:s}'
106)                 )
107)             setattr(self, name, val)
108) 
109)     def __repr__(self) -> str:
110)         vals = ', '.join([
111)             f'{name:s}={repr(getattr(self, name)):s}'
112)             for name in self._attrs.keys()
113)         ])
114)         return f'{type(self).__name__:s}({vals:s})'
115) 
116)     def _compare(self, other) -> int:
117)         if self._attrs != other._attrs:
118)             raise ValueError(f'{type(self).__name__:s} cannot be'
119)                              f' compared to {type(other).__name__:s}')
120)         for name in self._attrs:
121)             s = getattr(self, name)
122)             o = getattr(other, name)
123)             if s < o:
124)                 return -1
125)             if s > o:
126)                 return 1
127)         return 0
128) 
129)     def __eq__(self, other) -> bool:
130)         return self._compare(other) == 0
131) 
132)     def __ne__(self, other) -> bool:
133)         return self._compare(other) != 0
134) 
135)     def __lt__(self, other) -> bool:
136)         return self._compare(other) < 0
137) 
138)     def __le__(self, other) -> bool:
139)         return self._compare(other) <= 0
140) 
141)     def __gt__(self, other) -> bool:
142)         return self._compare(other) > 0
143) 
144)     def __ge__(self, other) -> bool:
145)         return self._compare(other) >= 0
146) 
147) 
148) class Element(Struct):
149)     """
150)     Element entity in a GNU PCB file.
151)     """
152) 

153)     _attrs = collections.OrderedDict([
154)         # attributes
155)         ('s_flags', []),
156)         ('desc', ''),
157)         ('name', ''),
158)         ('value', ''),
159)         ('m_x', Coordinate(0)),
160)         ('m_y', Coordinate(0)),
161)         ('t_x', Coordinate(0)),
162)         ('t_y', Coordinate(0)),
163)         ('t_dir', 0),
164)         ('t_scale', 0.0),
165)         ('t_s_flags', []),
166)         ('body', [])
167)     ])

168) 
169)     def __init__(self, **kwargs):
170)         super().__init__(**kwargs)
171) 
172) 
173) class ElementArc(Struct):
174)     """
175)     ElementArc entity in a GNU PCB file.
176)     """
177) 

178)     _attrs = collections.OrderedDict([
179)         # attributes
180)         ('r_x', Coordinate(0)),
181)         ('r_y', Coordinate(0)),
182)         ('width', Coordinate(0)),
183)         ('height', Coordinate(0)),
184)         ('start_angle', 0.0),
185)         ('end_angle', 0.0),
186)         ('thickness', Coordinate(0))
187)     ])

188) 
189)     def __init__(self, **kwargs):
190)         super().__init__(**kwargs)
191) 
192) 
193) class ElementLine(Struct):
194)     """
195)     ElementLine entity in a GNU PCB file.
196)     """
197) 

198)     _attrs = collections.OrderedDict([
199)         # attributes
200)         ('r_x1', Coordinate(0)),
201)         ('r_y1', Coordinate(0)),
202)         ('r_x2', Coordinate(0)),
203)         ('r_y2', Coordinate(0)),
204)         ('thickness', Coordinate(0))
205)     ])

206) 
207)     def __init__(self, **kwargs):
208)         super().__init__(**kwargs)
209) 
210) 
211) class Pad(Struct):
212)     """
213)     Pad entity in a GNU PCB file.
214)     """
215) 
216)     _attrs = collections.OrderedDict([

217)         # attributes
218)         ('r_x1', Coordinate(0)),
219)         ('r_y1', Coordinate(0)),
220)         ('r_x2', Coordinate(0)),
221)         ('r_y2', Coordinate(0)),
222)         ('thickness', Coordinate(0)),
223)         ('clearance', Coordinate(0)),
224)         ('mask', Coordinate(0)),

225)         ('name', ''),
226)         ('number', ''),
227)         ('s_flags', []),
228)     ])
229) 
230)     def __init__(self, **kwargs):
231)         super().__init__(**kwargs)
232) 
233) 
234) class Pin(Struct):
235)     """
236)     Pin entity in a GNU PCB file.
237)     """
238) 
239)     _attrs = collections.OrderedDict([

240)         # attributes
241)         ('r_x', Coordinate(0)),
242)         ('r_y', Coordinate(0)),
243)         ('thickness', Coordinate(0)),
244)         ('clearance', Coordinate(0)),
245)         ('mask', Coordinate(0)),
246)         ('drill', Coordinate(0)),