akcli-kicad 0.15.0__py3-none-any.whl

akcli/__init__.py

@@ -0,0 +1,46 @@
+"""akcli — read Altium .SchDoc and KiCad .kicad_sch, run checks, draw KiCad.
+
+Zero-runtime-dependency Python package (stdlib only). This top-level module exposes
+the package version and the analysis/protocol version constants used across the CLI.
+
+Name cascade (LOCKED): PyPI dist = ``akcli-kicad`` (the ``akcli`` name is
+taken on PyPI by an unrelated project); import package = ``akcli``; CLI =
+``akcli``.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+
+def _resolve_version() -> str:
+    """Report the version of the code actually running, dev checkout or install.
+
+    A co-located ``pyproject.toml`` (``project.name == "akcli-kicad"``) means we are
+    executing FROM the source tree; that file is the freshest truth and WINS —
+    an editable or older install otherwise pins stale metadata, so bumping the
+    working tree would not move ``akcli --version`` and a real update reads as
+    "unchanged" (the exact confusion the 0.7.0/design-integrity overlap caused).
+    An installed wheel has no such sibling pyproject, so it falls through to the
+    dist metadata. Last-resort ``"0.0.0"`` only if neither source is readable.
+    """
+    try:
+        import tomllib
+        from pathlib import Path
+
+        pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+        with pyproject.open("rb") as fh:
+            project = tomllib.load(fh).get("project", {})
+        if project.get("name") == "akcli-kicad" and project.get("version"):
+            return project["version"]
+    except Exception:
+        pass
+    try:
+        return _pkg_version("akcli-kicad")
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+__version__ = _resolve_version()
+
+__all__ = ["__version__"]

akcli/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m akcli`` entry point (thin shim over :func:`cli.main`)."""
+
+from __future__ import annotations
+
+from .cli import main
+
+raise SystemExit(main())

akcli/_vendor/jlc2kicadlib/LICENSE

@@ -0,0 +1,9 @@
+ The MIT License (MIT)
+
+Copyright © 2021 TousstNicolas 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

akcli/_vendor/jlc2kicadlib/PROVENANCE.md

@@ -0,0 +1,23 @@
+# Provenance — vendored JLC2KiCadLib
+
+- Upstream: https://github.com/TousstNicolas/JLC2KiCad_lib
+- License: MIT (see `LICENSE` in this directory, preserved verbatim)
+- Vendored commit: `48d36032108d64b0f59755234681f1ce8bc98d46`
+- Files taken: `helper.py`, `footprint/{footprint,footprint_handlers,model3d}.py`,
+  `symbol/{symbol,symbol_handlers}.py`. The upstream CLI entry
+  (`JLC2KiCadLib.py`) is NOT vendored — akcli drives `create_footprint` /
+  `create_symbol` directly from `drivers/jlc2kicad.py`.
+
+## Local modifications (kept minimal, all import-level)
+
+1. `import requests` → `from .. import _http as requests` (stdlib urllib shim;
+   keeps akcli zero-dependency).
+2. `from KicadModTree import ...` → `from .._kmt import ...`. **KicadModTree is
+   GPLv3+ and is deliberately not vendored or imported**; `_kmt.py` is an
+   original, clean-room implementation of just the API surface these files use,
+   written against the KiCad footprint *file format* (it emits the modern
+   `(footprint ...)` s-expression dialect rather than the legacy `(module ...)`
+   output of KicadModTree 1.x).
+
+`_http.py` and `_kmt.py` are original akcli code (project MIT license), not
+upstream files.

akcli/_vendor/jlc2kicadlib/__init__.py

@@ -0,0 +1,7 @@
+"""Vendored JLC2KiCadLib (MIT, (c) 2021 TousstNicolas) — see LICENSE + PROVENANCE.md.
+
+Only the conversion core is vendored (footprint/ + symbol/ + helper.py). Its two
+upstream dependencies are NOT vendored: ``requests`` is replaced by the stdlib
+shim ``_http`` and the GPLv3 ``KicadModTree`` by the clean-room ``_kmt`` writer
+(implemented from the KiCad footprint file format, not from KicadModTree code).
+"""

akcli/_vendor/jlc2kicadlib/_http.py

@@ -0,0 +1,49 @@
+"""Stdlib drop-in for the tiny slice of ``requests`` the vendored code uses.
+
+Original akcli code (project MIT license) — NOT an upstream JLC2KiCadLib file.
+Surface: ``get(url, headers=...)`` returning an object with ``.status_code`` and
+``.content``, plus ``codes.ok``. A module-level ``opener`` is injectable so
+tests run fully offline (same pattern as :mod:`akcli.parts.search`).
+"""
+
+from __future__ import annotations
+
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from types import SimpleNamespace
+
+# EasyEDA payloads are small JSON / STEP files; cap reads defensively.
+_MAX_BYTES = 64 * 1024 * 1024
+_TIMEOUT_S = 30.0
+
+#: Injectable transport: any object with ``open(request, *, timeout=...)``.
+opener = None
+
+codes = SimpleNamespace(ok=200)
+
+
+@dataclass
+class Response:
+    status_code: int
+    content: bytes
+
+    @property
+    def text(self) -> str:
+        return self.content.decode("utf-8", "replace")
+
+
+def get(url: str, headers: dict | None = None, timeout: float = _TIMEOUT_S) -> Response:
+    req = urllib.request.Request(url, headers=dict(headers or {}))
+    op = opener or urllib.request.build_opener()
+    try:
+        with op.open(req, timeout=timeout) as resp:
+            body = resp.read(_MAX_BYTES + 1)
+            if len(body) > _MAX_BYTES:
+                return Response(status_code=502, content=b"")
+            status = getattr(resp, "status", None) or resp.getcode() or 200
+            return Response(status_code=int(status), content=body)
+    except urllib.error.HTTPError as exc:  # non-2xx: report the code, never raise
+        return Response(status_code=int(exc.code), content=b"")
+    except (urllib.error.URLError, OSError, TimeoutError):
+        return Response(status_code=599, content=b"")

akcli/_vendor/jlc2kicadlib/_kmt.py

@@ -0,0 +1,339 @@
+"""Clean-room mini footprint writer replacing the GPLv3 ``KicadModTree``.
+
+Original akcli code (project MIT license) — NOT an upstream JLC2KiCadLib file,
+and NOT derived from KicadModTree's source: it implements, from the public
+KiCad footprint *file format*, exactly the API surface the vendored
+JLC2KiCadLib modules use (class names/kwargs are the interface those modules
+call; the serialization below is the modern ``(footprint ...)`` dialect KiCad
+7-10 read natively, not KicadModTree 1.x's legacy ``(module ...)`` output).
+
+Coordinate/unit contract: geometry values arrive in **mm** (the vendored
+handlers convert EasyEDA mils to mm). ``Model.at`` arrives in the legacy
+KicadModTree convention of **inches** and is serialized as an
+``(offset (xyz ...))`` in mm (x25.4).
+
+Dialect: the serializer emits the **KiCad 6** footprint dialect
+(``(layer ...) (width ...)`` on graphic items, version ``20211014``). Every
+KiCad from 6 through 10 reads it natively — and, decisively, so does **Altium
+Designer's Import Wizard** (File » Import Wizard » KiCad Design Files), whose
+KiCad support is pinned to 6.0x: the same converted library becomes an Altium
+``SchLib``/``PcbLib`` without any extra tool.
+"""
+
+from __future__ import annotations
+
+import math
+
+__all__ = [
+    "Arc", "Circle", "Footprint", "KicadFileHandler", "Line", "Model", "Pad",
+    "Polygon", "RectFill", "RectLine", "Text", "Translation", "Vector2D",
+]
+
+
+# --------------------------------------------------------------------------- #
+# small geometry helper (used by the vendored SVG-arc math)
+# --------------------------------------------------------------------------- #
+class Vector2D:
+    def __init__(self, x, y=None):
+        if y is None:  # Vector2D((x, y)) / Vector2D([x, y]) / Vector2D(other)
+            x, y = x[0], x[1]
+        self.x = float(x)
+        self.y = float(y)
+
+    def __getitem__(self, i):
+        return (self.x, self.y)[i]
+
+    def __add__(self, other):
+        return Vector2D(self.x + other[0], self.y + other[1])
+
+    def __mul__(self, k):
+        return Vector2D(self.x * k, self.y * k)
+
+    __rmul__ = __mul__
+
+    def rotate(self, degrees):
+        r = math.radians(degrees)
+        c, s = math.cos(r), math.sin(r)
+        return Vector2D(self.x * c - self.y * s, self.x * s + self.y * c)
+
+    def distance_to(self, other):
+        return math.hypot(self.x - other[0], self.y - other[1])
+
+
+def _xy(pt) -> tuple[float, float]:
+    return (float(pt[0]), float(pt[1]))
+
+
+def _fmt(v: float) -> str:
+    s = f"{float(v):.6f}".rstrip("0").rstrip(".")
+    return s if s not in ("-0", "") else "0"
+
+
+def _q(s: str) -> str:
+    return '"' + str(s).replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+# --------------------------------------------------------------------------- #
+# nodes (constructor kwargs == the surface the vendored handlers call)
+# --------------------------------------------------------------------------- #
+class Line:
+    def __init__(self, start, end, width, layer):
+        self.start, self.end = _xy(start), _xy(end)
+        self.width, self.layer = float(width), layer
+
+
+class Arc:
+    def __init__(self, start, end, center, width, layer):
+        self.start, self.end, self.center = _xy(start), _xy(end), _xy(center)
+        self.width, self.layer = float(width), layer
+
+
+class Circle:
+    def __init__(self, center, radius, width, layer):
+        self.center, self.radius = _xy(center), float(radius)
+        self.width, self.layer = float(width), layer
+
+
+class Polygon:
+    def __init__(self, nodes, layer=None, width=0.0):
+        self.nodes = [_xy(p) for p in nodes]  # materialize (callers pass zip())
+        self.layer, self.width = layer, float(width)
+
+
+class RectLine:
+    def __init__(self, start, end, width, layer):
+        self.start, self.end = _xy(start), _xy(end)
+        self.width, self.layer = float(width), layer
+
+
+class RectFill:
+    def __init__(self, start, end, layer):
+        self.start, self.end, self.layer = _xy(start), _xy(end), layer
+
+
+class Text:
+    def __init__(self, type, text, at, layer):  # noqa: A002 - upstream kwarg name
+        self.type, self.text = type, str(text)
+        self.at, self.layer = _xy(at), layer
+
+
+class Pad:
+    TYPE_THT = "thru_hole"
+    TYPE_SMT = "smd"
+    TYPE_NPTH = "np_thru_hole"
+    SHAPE_CIRCLE = "circle"
+    SHAPE_OVAL = "oval"
+    SHAPE_RECT = "rect"
+    SHAPE_CUSTOM = "custom"
+    LAYERS_THT = ["*.Cu", "*.Mask"]
+    LAYERS_SMT = ["F.Cu", "F.Paste", "F.Mask"]
+    LAYERS_NPTH = ["*.Cu", "*.Mask"]
+
+    def __init__(self, number, type, shape, at, size, layers,  # noqa: A002
+                 rotation=0.0, drill=None, primitives=""):
+        self.number = str(number)
+        self.type = type
+        self.shape = shape
+        self.at = _xy(at)
+        self.size = _xy(size) if isinstance(size, (list, tuple)) else (float(size), float(size))
+        self.rotation = float(rotation or 0.0)
+        self.drill = drill
+        self.layers = list(layers)
+        self.primitives = list(primitives) if primitives else []
+
+
+class Model:
+    def __init__(self, filename, at, rotate, scale=(1.0, 1.0, 1.0)):
+        # upstream sometimes pre-quotes path-variable filenames — strip that.
+        self.filename = str(filename).strip('"')
+        self.at = tuple(float(v) for v in at)          # legacy inches
+        self.rotate = tuple(float(v) for v in rotate)
+        self.scale = tuple(float(v) for v in scale)
+
+
+class Translation:
+    """Container that offsets everything inside it (the only transform used)."""
+
+    def __init__(self, x, y):
+        self.offset = (float(x), float(y))
+        self.children: list = []
+
+    def append(self, node) -> None:
+        self.children.append(node)
+
+
+class Footprint:
+    def __init__(self, name):
+        self.name = str(name).strip('"')  # upstream passes a pre-quoted name
+        self.description = ""
+        self.tags = ""
+        self.attribute = "smd"
+        self.children: list = []
+
+    def setDescription(self, s):  # noqa: N802 - upstream API name
+        self.description = str(s)
+
+    def setTags(self, s):  # noqa: N802
+        self.tags = str(s)
+
+    def setAttribute(self, s):  # noqa: N802
+        self.attribute = str(s)
+
+    def append(self, node) -> None:
+        self.children.append(node)
+
+    def insert(self, node) -> None:
+        """Re-parent all current children under ``node`` (Translation wrap)."""
+        if isinstance(node, Translation):
+            node.children = self.children
+            self.children = [node]
+        else:
+            self.children.append(node)
+
+    def getAllChilds(self):  # noqa: N802
+        out = []
+        stack = list(self.children)
+        while stack:
+            n = stack.pop()
+            out.append(n)
+            stack.extend(getattr(n, "children", []) or [])
+        return out
+
+
+# --------------------------------------------------------------------------- #
+# serialization — modern (footprint ...) s-expression
+# --------------------------------------------------------------------------- #
+def _shift(pt, off):
+    return (pt[0] + off[0], pt[1] + off[1])
+
+
+def _arc_mid(start, end, center):
+    """Point on the arc halfway from start to end (clockwise, +Y-down plane).
+
+    The vendored handler normalizes SVG sweep so the arc always runs clockwise
+    (screen sense, +Y down) from ``start`` to ``end`` around ``center``.
+    """
+    a0 = math.atan2(start[1] - center[1], start[0] - center[0])
+    a1 = math.atan2(end[1] - center[1], end[0] - center[0])
+    r = math.hypot(start[0] - center[0], start[1] - center[1])
+    sweep = (a1 - a0) % (2 * math.pi)  # CW in y-down == increasing atan2 angle
+    am = a0 + sweep / 2.0
+    return (center[0] + r * math.cos(am), center[1] + r * math.sin(am))
+
+
+def _gtail(layer, width):
+    """KiCad-6 graphic-item tail: ``(layer "X") (width W)`` (no stroke node)."""
+    return f"(layer {_q(layer)}) (width {_fmt(width)})"
+
+
+def _serialize_node(node, off, out: list[str]) -> None:
+    ind = "\t"
+    if isinstance(node, Translation):
+        noff = (off[0] + node.offset[0], off[1] + node.offset[1])
+        for child in node.children:
+            _serialize_node(child, noff, out)
+        return
+    if isinstance(node, Line):
+        s, e = _shift(node.start, off), _shift(node.end, off)
+        out.append(f"{ind}(fp_line (start {_fmt(s[0])} {_fmt(s[1])}) "
+                   f"(end {_fmt(e[0])} {_fmt(e[1])}) {_gtail(node.layer, node.width)})")
+    elif isinstance(node, RectLine) or isinstance(node, RectFill):
+        s, e = _shift(node.start, off), _shift(node.end, off)
+        width = getattr(node, "width", 0.0)
+        fill = "none" if isinstance(node, RectLine) else "solid"
+        out.append(f"{ind}(fp_rect (start {_fmt(s[0])} {_fmt(s[1])}) "
+                   f"(end {_fmt(e[0])} {_fmt(e[1])}) {_gtail(node.layer, width)} "
+                   f"(fill {fill}))")
+    elif isinstance(node, Arc):
+        s, e = _shift(node.start, off), _shift(node.end, off)
+        c = _shift(node.center, off)
+        m = _arc_mid(s, e, c)
+        out.append(f"{ind}(fp_arc (start {_fmt(s[0])} {_fmt(s[1])}) "
+                   f"(mid {_fmt(m[0])} {_fmt(m[1])}) (end {_fmt(e[0])} {_fmt(e[1])}) "
+                   f"{_gtail(node.layer, node.width)})")
+    elif isinstance(node, Circle):
+        c = _shift(node.center, off)
+        out.append(f"{ind}(fp_circle (center {_fmt(c[0])} {_fmt(c[1])}) "
+                   f"(end {_fmt(c[0] + node.radius)} {_fmt(c[1])}) "
+                   f"{_gtail(node.layer, node.width)} (fill none))")
+    elif isinstance(node, Polygon):
+        pts = " ".join(f"(xy {_fmt(p[0] + off[0])} {_fmt(p[1] + off[1])})"
+                       for p in node.nodes)
+        layer = node.layer or "F.Fab"
+        out.append(f"{ind}(fp_poly (pts {pts}) {_gtail(layer, node.width)} "
+                   f"(fill solid))")
+    elif isinstance(node, Text):
+        a = _shift(node.at, off)
+        out.append(f"{ind}(fp_text {node.type} {_q(node.text)} "
+                   f"(at {_fmt(a[0])} {_fmt(a[1])}) (layer {_q(node.layer)}) "
+                   f"(effects (font (size 1 1) (thickness 0.15))))")
+    elif isinstance(node, Pad):
+        a = _shift(node.at, off)
+        at = (f"(at {_fmt(a[0])} {_fmt(a[1])}"
+              + (f" {_fmt(node.rotation)}" if node.rotation else "") + ")")
+        parts = [f"(pad {_q(node.number)} {node.type} {node.shape} {at} "
+                 f"(size {_fmt(node.size[0])} {_fmt(node.size[1])})"]
+        drill = node.drill
+        if drill and node.type in (Pad.TYPE_THT, Pad.TYPE_NPTH):
+            if isinstance(drill, (list, tuple)):
+                parts.append(f"(drill oval {_fmt(drill[0])} {_fmt(drill[1])})")
+            elif float(drill) > 0:
+                parts.append(f"(drill {_fmt(drill)})")
+        parts.append("(layers " + " ".join(_q(layer) for layer in node.layers) + ")")
+        if node.shape == Pad.SHAPE_CUSTOM and node.primitives:
+            prims = []
+            for prim in node.primitives:
+                if isinstance(prim, Polygon):
+                    pts = " ".join(f"(xy {_fmt(p[0])} {_fmt(p[1])})" for p in prim.nodes)
+                    prims.append(f"(gr_poly (pts {pts}) (width 0) (fill yes))")
+            parts.append("(options (clearance outline) (anchor circle)) "
+                         "(primitives " + " ".join(prims) + ")")
+        out.append(ind + " ".join(parts) + ")")
+    elif isinstance(node, Model):
+        o = tuple(v * 25.4 for v in node.at)  # legacy inches -> mm offset
+        out.append(
+            f"{ind}(model {_q(node.filename)}\n"
+            f"{ind}\t(offset (xyz {_fmt(o[0])} {_fmt(o[1])} {_fmt(o[2])}))\n"
+            f"{ind}\t(scale (xyz {_fmt(node.scale[0])} {_fmt(node.scale[1])} "
+            f"{_fmt(node.scale[2])}))\n"
+            f"{ind}\t(rotate (xyz {_fmt(node.rotate[0])} {_fmt(node.rotate[1])} "
+            f"{_fmt(node.rotate[2])}))\n"
+            f"{ind})"
+        )
+    # unknown nodes are ignored (none exist in the vendored call surface)
+
+
+class KicadFileHandler:
+    def __init__(self, footprint: Footprint):
+        self.footprint = footprint
+
+    def serialize(self) -> str:
+        fp = self.footprint
+        lines = [
+            f"(footprint {_q(fp.name)}",
+            "\t(version 20211014)",
+            "\t(generator akcli)",
+            '\t(layer "F.Cu")',
+            f"\t(descr {_q(fp.description)})",
+            f"\t(tags {_q(fp.tags)})",
+            f"\t(attr {fp.attribute})",
+        ]
+        body: list[str] = []
+        for child in fp.children:
+            _serialize_node(child, (0.0, 0.0), body)
+        # KiCad expects graphics/text before pads before models; keep a stable
+        # grouped order for diffability.
+        def _rank(line: str) -> int:
+            if line.lstrip("\t").startswith("(pad"):
+                return 1
+            if line.lstrip("\t").startswith("(model"):
+                return 2
+            return 0
+        body.sort(key=_rank)
+        lines.extend(body)
+        lines.append(")")
+        return "\n".join(lines) + "\n"
+
+    def writeFile(self, path) -> None:  # noqa: N802 - upstream API name
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write(self.serialize())

akcli/_vendor/jlc2kicadlib/footprint/footprint.py

@@ -0,0 +1,181 @@
+import json
+import logging
+import os
+from dataclasses import dataclass
+
+from .. import _http as requests
+from .._kmt import Footprint, KicadFileHandler, Pad, Text, Translation
+
+from .. import helper
+from .footprint_handlers import handlers, mil2mm
+
+
+@dataclass
+class FootprintInfo:
+    max_X: float = -10000
+    max_Y: float = -10000
+    min_X: float = 10000
+    min_Y: float = 10000
+    footprint_name: str = ""
+    output_dir: str = ""
+    footprint_lib: str = ""
+    model_base_variable: str = ""
+    model_dir: str = ""
+    origin: tuple = (0, 0)
+    models: str = ""
+
+
+def create_footprint(
+    footprint_component_uuid,
+    component_id,
+    footprint_lib,
+    output_dir,
+    model_base_variable,
+    model_dir,
+    skip_existing,
+    models,
+):
+    logging.info("Creating footprint ...")
+
+    (
+        footprint_name,
+        datasheet_link,
+        footprint_shape,
+        translation,
+    ) = get_footprint_info(footprint_component_uuid)
+
+    if skip_existing and os.path.isfile(
+        os.path.join(output_dir, footprint_lib, footprint_name + ".kicad_mod")
+    ):
+        logging.info(f"Footprint {footprint_name} already exists, skipping.")
+        return f"{footprint_lib}:{footprint_name}", datasheet_link
+
+    # init kicad footprint
+    kicad_mod = Footprint(f'"{footprint_name}"')
+    kicad_mod.setDescription(f"{footprint_name} footprint")  # TODO Set real description
+    kicad_mod.setTags(f"{footprint_name} footprint {component_id}")
+
+    footprint_info = FootprintInfo(
+        footprint_name=footprint_name,
+        output_dir=output_dir,
+        footprint_lib=footprint_lib,
+        model_base_variable=model_base_variable,
+        model_dir=model_dir,
+        origin=translation,
+        models=models,
+    )
+
+    # for each line in data : use the appropriate handler
+    for line in footprint_shape:
+        args = [i for i in line.split("~")]  # split and remove empty string in list
+        model = args[0]
+        logging.debug(args)
+        if model not in handlers:
+            logging.warning(f"footprint : model not in handler :  {model}")
+        else:
+            handlers.get(model)(args[1:], kicad_mod, footprint_info)
+
+    if any(
+        isinstance(child, Pad) and child.type == Pad.TYPE_THT
+        for child in kicad_mod.getAllChilds()
+    ):
+        kicad_mod.setAttribute("through_hole")
+    else:
+        kicad_mod.setAttribute("smd")
+
+    kicad_mod.insert(Translation(-mil2mm(translation[0]), -mil2mm(translation[1])))
+
+    # Translate the footprint max and min values to the origin
+    footprint_info.max_X -= mil2mm(translation[0])
+    footprint_info.max_Y -= mil2mm(translation[1])
+    footprint_info.min_X -= mil2mm(translation[0])
+    footprint_info.min_Y -= mil2mm(translation[1])
+
+    # set general values
+    kicad_mod.append(
+        Text(
+            type="reference",
+            text="REF**",
+            at=[
+                (footprint_info.min_X + footprint_info.max_X) / 2,
+                footprint_info.min_Y - 2,
+            ],
+            layer="F.SilkS",
+        )
+    )
+    kicad_mod.append(
+        Text(
+            type="user",
+            text="${REFERENCE}",
+            at=[
+                (footprint_info.min_X + footprint_info.max_X) / 2,
+                (footprint_info.min_Y + footprint_info.max_Y) / 2,
+            ],
+            layer="F.Fab",
+        )
+    )
+    kicad_mod.append(
+        Text(
+            type="value",
+            text=footprint_name,
+            at=[
+                (footprint_info.min_X + footprint_info.max_X) / 2,
+                footprint_info.max_Y + 2,
+            ],
+            layer="F.Fab",
+        )
+    )
+
+    if not os.path.exists(f"{output_dir}/{footprint_lib}"):
+        os.makedirs(f"{output_dir}/{footprint_lib}")
+
+    # output kicad model
+    file_handler = KicadFileHandler(kicad_mod)
+    file_handler.writeFile(f"{output_dir}/{footprint_lib}/{footprint_name}.kicad_mod")
+    logging.info(f"Created '{output_dir}/{footprint_lib}/{footprint_name}.kicad_mod'")
+
+    # return the datasheet link and footprint name to be linked with the symbol
+    return (f"{footprint_lib}:{footprint_name}", datasheet_link)
+
+
+def get_footprint_info(footprint_component_uuid):
+    # fetch the component data from easyeda library
+    response = requests.get(
+        f"https://easyeda.com/api/components/{footprint_component_uuid}",
+        headers={"User-Agent": helper.get_user_agent()},
+    )
+
+    if response.status_code == requests.codes.ok:
+        data = json.loads(response.content.decode())
+    else:
+        logging.error(
+            "create_footprint error. Requests returned with error code "
+            f"{response.status_code}"
+        )
+        return ("", None, "", (0, 0))
+
+    footprint_shape = data["result"]["dataStr"]["shape"]
+    x = data["result"]["dataStr"]["head"]["x"]
+    y = data["result"]["dataStr"]["head"]["y"]
+    try:
+        datasheet_link = data["result"]["dataStr"]["head"]["c_para"]["link"]
+    except KeyError:
+        datasheet_link = ""
+        logging.warning("Could not retrieve datasheet link from EASYEDA")
+
+    footprint_name = (
+        data["result"]["title"]
+        .replace(" ", "_")
+        .replace("/", "_")
+        .replace("(", "_")
+        .replace(")", "_")
+    )
+
+    if not footprint_name:
+        footprint_name = "NoName"
+        logging.warning(
+            "Could not retrieve components information from EASYEDA, default name "
+            "'NoName'."
+        )
+
+    return (footprint_name, datasheet_link, footprint_shape, (x, y))