def test_Heterogenous(self):
J = Swoop.Mixin(self.Jumper, "Jump")
W = Swoop.Mixin(self.Walker, "Walk")
js = J.from_file(self.me + "/inputs/test06.sch")
ws = W.from_file(self.me + "/inputs/test06.sch")
jl = J.from_file(self.me + "/inputs/Components.lbr")
wl = W.from_file(self.me + "/inputs/Components.lbr")
# print EagleFile.class_map["library"]
# print J.class_map["library"]
# print W.class_map["library"]
# print "2here " + str(type(js.get_libraries()[0]))
# print js.get_libraries()[0].do_it()
# print ws.get_libraries()[0].do_it()
# print jl.get_library().get_packages()[0].do_it()
# print wl.get_library().get_packages()[0].do_it()
self.assertEqual(js.get_libraries()[0].do_it(), "jump",
"Heterogenous extension error")
self.assertEqual(ws.get_libraries()[0].do_it(), "walk",
"Heterogenous extension error")
self.assertEqual(jl.get_library().get_packages()[0].do_it(), "jump",
"Heterogenous extension error")
self.assertEqual(wl.get_library().get_packages()[0].do_it(), "walk",
"Heterogenous extension error")
self.assertEqual(type(jl.new_Package()),
type(jl.get_library().get_packages()[0]),
"EFP factory error")
def setUp(self):
#log.basicConfig(format="%(levelname)s: %(message)s", level=log.DEBUG)
NewEagleFile = Swoop.Mixin(self.MyMixin, "Typer")
self.me = os.path.dirname(os.path.realpath(__file__))
self.sch = NewEagleFile.from_file(
self.me +
"/inputs/Xperimental_Trinket_Pro_small_parts_power_breakout.picked.sch"
)
self.brd = NewEagleFile.from_file(
self.me +
"/inputs/Xperimental_Trinket_Pro_small_parts_power_breakout.picked.brd"
)
self.lbr = NewEagleFile.from_file(self.me + "/inputs/Components.lbr")
NewEagleFileMod = Swoop.Mixin(testExt, "Mod")
#print(NewEagleFile.__name__)
self.lbr2 = NewEagleFileMod.from_file(self.me +
"/inputs/Components.lbr")
AreaEagleFile = Swoop.Mixin(Area, "Area")
#print(NewEagleFile.__name__)
self.lbr_area = AreaEagleFile.from_file(self.me +
"/inputs/Components.lbr")
def test_Composition(self):
J = Swoop.Mixin(self.Jumper, "Jump")
WJ = Swoop.Mixin(self.Walker, "Walk", base=J)
wjl = WJ.from_file(self.me + "/inputs/Components.lbr")
self.assertEqual(wjl.get_library().jump(), "jump",
"Extension composition error")
self.assertEqual(wjl.get_library().walk(), "walk",
"Extension composition error")
WJA = Swoop.Mixin(Area, "Area", base=WJ)
wjal = WJA.from_file(self.me + "/inputs/Components.lbr")
self.assertAlmostEqual(From(wjal).get_library().get_packages(
).get_drawing_elements().with_type(Rectangle).get_area().reduce(
lambda x, y: x + y, init=0.0),
7711.54157257,
places=5,
msg="Extension composition error")
A = Swoop.Mixin(Area, "Area")
AJ = Swoop.Mixin(self.Jumper, "Jump", base=A)
ajl = AJ.from_file(self.me + "/inputs/Components.lbr")
self.assertAlmostEqual(From(ajl).get_library().get_packages(
).get_drawing_elements().with_type(Rectangle).get_area().reduce(
lambda x, y: x + y, init=0.0),
7711.54157257,
places=7,
msg="Extension composition error")
def test_Example(self):
class AttrMixin(object):
def __init__(self):
self.attrs = {}
def set_attr(self, n, v):
self.attrs[n] = v
return self
def get_attr(self, n):
return self.attrs.get(n)
AttrEagleFile = Swoop.Mixin(AttrMixin, "Attr")
sch = AttrEagleFile.open(self.me + "/inputs/test05.sch")
sch.get_library("PickerDesign").get_symbol(
"GENERIC-RESISTOR_").set_attr("good?", "yes!")
self.assertEqual(
sch.get_library("PickerDesign").get_symbol(
"GENERIC-RESISTOR_").get_attr("good?"), "yes!",
"Attr mixin error")
else:
return do_intersect(self.cgal_elem, iso_rect_query)
# Primitive drawing elements: Pad, Smd, Via, Rectangle, Wire, Polygon, Text?
# And now some monkey patching
def get_package_moved(self):
return self.package_moved
Swoop.Element.get_package_moved = get_package_moved
WithMixin = Swoop.Mixin(GeometryMixin, "geo")
class BoardFile(Swoop.From):
"""
A wrapper around Swoop.BoardFile that adds some geometric methods
Requires CGAL
"""
def __init__(self, filename):
"""
Completely overrides the parent constructor
Need a few things to init from:
-All <elements> (parts on the board)
-Random other stuff from <signals> or <plain>
for k in i.interiors:
data = data + "M{} {} ".format(
k.coords[0][0], k.coords[0][1]) + " ".join(
["L{} {}".format(x[0], x[1])
for x in k.coords[1:]]) + closer
r = r + ("<path {} {} d='{}'/>".format(svgclass, style, data))
return r
def hash_geometry(geo):
"""Hash a shapley geometry object. The algorithm is a little ad hoc: We
converting it to string, rounding all the floats found in the string, and
sort the contents of the string character-wise, and take a hash of the
result. This handles allows for matches even when the answers differ very
slightly due to floating point problems and the unfortunate fact that
Shapely doesn't always return objects in the same order.
"""
def trim(match):
return str(round(float(match.group(0)), 5))
v = re.sub("-?\d+(\.\d+)?", trim, str(geo))
return hash("".join(sorted(v)))
import sys
ShapelySwoop = Swoop.Mixin(sys.modules[__name__], "Shapely")
