vscode 使用 python 进行 UG 二次开发 实现代码提示功能

vscode 使用 python 进行 UG 二次开发的 实现代码提示功能

用 VSCODE 进行 UG 二次开发的时候， 想要用代码提示的时候，可以用 pydev 插件， 但是，pydev 只有一个月的试用期，那到用 pylance 可不可以有相似的效果吗？

答案是可以。

方法是 自己生成 NXOpen.pyi 文件。

---

自已写了一段代码，用于简单的生成 这个 文件。

• 先运行这个代码，生成 NXOpen 文件夹，
• 再把这个文件夹移动到 NXBIN/python目录下。

---

__version__ = "0.0.4"
__author__ = "unmht"
from typing import Dict, Generator, List, Optional
import NXOpen
import types
import os
import re
from importlib import import_module

ugii_base_dir = os.getenv("UGII_BASE_DIR")

pp = os.path.join(str(ugii_base_dir), "nxbin", "python")

imp_mds = {}
for root, dirs, files in os.walk(pp, topdown=True):

    if root != pp:
        break

    for ff in files:
        # print(ff)
        if str(ff).startswith("NXOpen_") and str(ff).endswith(".pyd"):
            module_name = str(ff)[:-4]
            # print(module_name)
            try:
                ms = module_name.split("_")[-1]
                imp_mds[ms] = import_module(module_name)
            except Exception as e:
                print("error:", module_name, e)

class pyibase:

    ecpts = [
        "NXObject",
        "TaggedObject",
        "INXObject",
    ]

    def __init__(self) -> None:
        self.name: str = ""
        self.doc: Optional[str] = ""
        self.chdmdls: Dict = {}
        self.chdtps: Dict = {}
        self.MdDescriptor: Dict = {}
        self.GSDescriptor: Dict = {}
        self.unct: Dict = {}
        self.nxc: Dict[str, "nxoClsAliasType | pyibase"] = {}
        self.mthdorbutin: Dict = {}
        self.mberDescriptor: Dict = {}

        self.tpsinvoke: Dict[str, List] = {}
        self.nn: List[str] = []

    def dcts(self) -> Generator["pyibase", None, None]:
        for dc in [
            self.chdmdls,
            self.chdtps,
            self.MdDescriptor,
            self.GSDescriptor,
            self.unct,
            self.nxc,
            self.mthdorbutin,
            self.mberDescriptor,
        ]:
            for v in dc.values():
                yield v

    def addmember(self, m, dm: List[str] = None):

        dirm = dir(m)
        if dm is not None:
            dirm = [i for i in dirm if i not in dm]
        for i in dirm:
            if i == "GetSession":
                print(i)
            if not i.startswith("_"):
                att = getattr(m, i)
                self.nn.append(i)
                if isinstance(att, types.ModuleType):
                    self.chdmdls[i] = nxoModuleType(att)
                elif isinstance(att, type):
                    if i != att.__name__:
                        self.tpsinvoke[i] = [att.__module__, att.__name__]
                    elif i not in pyibase.ecpts:
                        self.chdtps[i] = nxoType(att)
                elif isinstance(att, types.MethodDescriptorType):
                    self.MdDescriptor[i] = nxoMethodDescriptorType(att)
                elif isinstance(att, types.GetSetDescriptorType):
                    self.GSDescriptor[i] = nxoGetSetDescriptorType(att)
                elif isinstance(att, types.MemberDescriptorType):
                    self.mberDescriptor[i] = nxoMemberDescriptorType(att)
                else:
                    _md = att.__class__.__module__
                    if "NXOpen" in str(_md):
                        self.nxc[i] = nxoClsAliasType(att, i)
                    elif i == "ValueOf":
                        self.mthdorbutin[i] = nxoBuiltinFunctionType(att)
                    elif isinstance(att, types.BuiltinFunctionType):
                        self.mthdorbutin[i] = nxoBuiltinFunctionType(
                            att, cname=self.name
                        )
                    else:
                        assert TypeError(i, att, type(att))

    def docs(self, lv: int = 0, mx: int = 130):
        dd = str(self.doc)
        dd = dd.strip()
        dd2 = dd.splitlines()
        dd2 = [i.strip() for i in dd2]

        ll = mx - lv * 4
        yield (lv + 1) * "\t" + "'''"
        yield (lv + 1) * "\t" + f"### {self.__class__.__name__}"

        for i in dd2:
            for k in range(0, len(i), ll):
                yield (lv + 1) * "\t" + i[k : min(len(i), k + ll)]
        yield (lv + 1) * "\t" + "'''"

    def toStr(self, lv: int = 0, mx: int = 130):
        yield lv * "\t" + f"{self.name}:-->"

class nxoModuleType(pyibase):
    def __init__(self, m: types.ModuleType) -> None:
        super().__init__()
        assert isinstance(m, types.ModuleType)
        self.doc = m.__doc__
        self.name = m.__name__.split(".")[-1]

        self.addmember(m)

    def toStr(self, lv: int = 0, mx: int = 130):
        yield lv * "\t" + f"class {self.name}:"
        for i in self.docs(lv):
            yield i
        for dc in self.dcts():
            for i in dc.toStr(lv + 1):
                yield i
        for i, v in self.tpsinvoke.items():
            _a = ".".join(v)
            yield "\t" + f"{i}={_a}"

class basetps(pyibase):
    def __init__(self, m: type, name="") -> None:
        super().__init__()
        assert name in pyibase.ecpts
        self.name = name
        self.doc = m.__doc__
        self.mo = type.mro(m)
        self.addmember(m)

    def toStr(self, lv=0, mx=130):
        if self.name in ["TaggedObject", "INXObject"]:
            yield lv * "\t" + f"class {self.name}(object):"
        elif self.name == "NXObject":
            yield lv * "\t" + f"class {self.name}(NXOpen.TaggedObject,NXOpen.INXObject):"
        else:
            yield lv * "\t" + f"class {self.name}(object):"
        for i in self.docs(lv):
            yield i
        for v in self.dcts():
            for ss in v.toStr(lv + 1):
                yield ss
        for i, v in self.tpsinvoke.items():
            _a = ".".join(v)
            yield lv * "\t" + "\t" + f"{i}={_a}"

class nxoType(pyibase):
    def __init__(self, m: type) -> None:
        super().__init__()
        assert isinstance(m, type)
        self.doc = m.__doc__
        self.name = m.__name__
        self.mo = type.mro(m)
        self.sp = self.mo[1]
        ll = []
        for k in self.mo[1:]:
            for s in dir(k):
                if not s.startswith("_"):
                    ll.append(s)
        self.addmember(m, ll)

    def toStr(self, lv=0, mx=130):

        yield lv * "\t" + f"class {self.name}({str(self.sp)[8:-2]}):"
        for i in self.docs(lv):
            yield i

        for v in self.dcts():
            for i in v.toStr(lv + 1):
                yield i
        for i, v in self.tpsinvoke.items():
            _a = ".".join(v)
            yield lv * "\t" + "\t" + f"{i}={_a}"

pt1 = r":returns:[ \S]*[\n]?\s*:rtype: :py:class:`([\S]+)`"
p1 = re.compile(pt1)
pt2 = r":returns:[ \S]*[\n]?\s*:rtype: list of :py:class:`([\S]+)`"
p2 = re.compile(pt2)
pt3 = r":returns:[ \S]*[\n]?\s*:rtype: ([\S]+)"
p3 = re.compile(pt3)
pt4 = r":returns:[ \S]*[\n]?\s*:rtype: list of ([\S]+)"
p4 = re.compile(pt4)

def findrtype(ss: str):
    rtp = ""
    r = p1.search(ss)
    if r is not None:
        rtp = r.groups()[0]
    if rtp == "":
        r = p2.search(ss)
        if r is not None:
            rtp = f"List[{r.groups()[0]}]"
    if rtp == "":
        r = p3.search(ss)
        if r is not None:
            rtp = r.groups()[0]
            if rtp not in ["int", "str", "float", "bool"]:
                rtp = ""
    if rtp == "":
        r = p4.search(ss)
        if r is not None:
            rtp = r.groups()[0]
            if rtp not in ["int", "str", "float", "bool"]:
                rtp = ""
            else:
                rtp = f"List[{rtp}]"
    return rtp

class nxoMethodDescriptorType(pyibase):
    def __init__(self, m: types.MethodDescriptorType) -> None:
        super().__init__()
        assert isinstance(m, types.MethodDescriptorType)
        self.doc = m.__doc__
        self.name = m.__name__

    def toStr(self, lv: int = 0, mx: int = 130):
        rtp = findrtype(str(self.doc))

        if rtp == "":
            rr = ""
        else:
            rr = f"->{rtp}"
        if self.name == "Dispose":
            yield lv * "\t" + f"def {self.name}(self){rr}:"
        else:
            yield lv * "\t" + f"def {self.name}(self,*args,**kw){rr}:"
        for i in self.docs(lv):
            yield i
        yield lv * "\t" + "\t" + "..."

class nxoGetSetDescriptorType(pyibase):
    def __init__(self, m: types.GetSetDescriptorType) -> None:
        super().__init__()
        assert isinstance(m, types.GetSetDescriptorType)
        self.doc = m.__doc__
        self.name = m.__name__

    def toStr(self, lv: int = 0, mx: int = 130):
        rtp = findrtype(str(self.doc))

        yield lv * "\t" + f"@property"
        if rtp == "":
            yield lv * "\t" + f"def {self.name}(self):"
        else:
            yield lv * "\t" + f"def {self.name}(self)->{rtp}:"
        for i in self.docs(lv):
            yield i
        yield lv * "\t" + "\t" + "..."

        yield lv * "\t" + f"@{self.name}.setter"
        if rtp == "":
            yield lv * "\t" + f"def {self.name}(self,value):..."
        else:
            yield lv * "\t" + f"def {self.name}(self,value:{rtp}):..."
        yield ""

class nxoMemberDescriptorType(pyibase):
    def __init__(self, m: types.MemberDescriptorType) -> None:
        super().__init__()
        assert isinstance(m, types.MemberDescriptorType)
        self.doc = m.__doc__
        self.name = m.__name__
        self._tp = type(m).__name__

    def toStr(self, lv: int = 0, mx: int = 130):
        yield lv * "\t" + f"{self.name}:{self._tp}=..."
        for i in self.docs(lv):
            yield i

class nxoBuiltinFunctionType(pyibase):
    def __init__(
        self, m: "types.MemberDescriptorType |types.BuiltinMethodType", cname=""
    ) -> None:
        super().__init__()
        assert isinstance(m, types.BuiltinFunctionType) and isinstance(
            m, types.BuiltinMethodType
        )
        self.doc = m.__doc__
        self.name = m.__name__
        self.cname = cname

    def toStr(self, lv: int = 0, mx: int = 130):
        rtp = findrtype(str(self.doc))
        yield lv * "\t" + f"@classmethod"
        if self.name == "ValueOf":
            yield lv * "\t" + f"def {self.name}(cls,value:int):"
        elif rtp != "":
            yield lv * "\t" + f"def {self.name}(cls,*args,**kw)->{rtp}:"
        elif self.cname != "" and self.name == "Get" + self.cname:
            if hasattr(NXOpen, self.cname):
                yield lv * "\t" + f"def {self.name}(cls,*args,**kw)->NXOpen.{self.cname}:"
            else:
                yield lv * "\t" + f"def {self.name}(cls,*args,**kw)->{self.cname}:"
        else:
            yield lv * "\t" + f"def {self.name}(cls,*args,**kw):"
        for i in self.docs(lv):
            yield i
        yield lv * "\t" + "\t" + "..."

class nxoClsAliasType(pyibase):
    def __init__(self, m, name="") -> None:
        super().__init__()
        _md = m.__class__.__module__
        assert "NXOpen" in str(_md)
        self.doc = m.__doc__
        self.name = m.__name__ if hasattr(m, "__name__") else name
        self.attp = str(m.__class__.__name__)
        self.body = m

    def toStr(self, lv=0, mx=130):
        nn = self.attp
        if hasattr(NXOpen, nn):
            att = getattr(NXOpen, nn)
            if isinstance(att, type):
                nn = f"NXOpen.{nn}"
        else:
            nn = self.body.__class__.__module__ + "." + self.body.__class__.__name__
        if self.name == "KeyPerformanceInterface":
            print(self.name, f"{self.name}:{nn}=...")
        yield lv * "\t" + f"{self.name}:{nn}=..."
        for i in self.docs(lv - 1):
            yield i

class mainModules(pyibase):
    def __init__(
        self,
    ) -> None:
        super().__init__()
        m = NXOpen
        self.doc = m.__doc__
        self.name = m.__name__
        self.addmember(m)
        for i in pyibase.ecpts:
            self.chdtps[i] = basetps(getattr(NXOpen, i), i)
        for k, v in imp_mds.items():
            self.chdmdls[k] = nxoModuleType(v)

    def pyi(self):
        mm = self
        if not os.path.exists("./NXOpen/"):
            os.mkdir("./NXOpen")

        if not os.path.exists("./NXOpen/clss/"):
            os.mkdir("./NXOpen/clss/")

        p11 = "./NXOpen/"
        p22 = os.path.join(p11, "clss/")

        with open(os.path.join(p11, "__init__.py"), "w", encoding="utf8") as f:
            m: nxoModuleType
            for v in mm.chdmdls.values():
                m = v
                mn = m.name.split(".")[-1]
                mName = mn + ".pyi"
                with open(os.path.join(p11, mName), "w") as f2:
                    f2.write("import NXOpen\n")
                    f2.write("from typing import List\n")
                    for _s in m.toStr():
                        f2.write(_s + "\n")

                f.write(f"from .{mn} import {mn} as {mn}" + "\n")
            f.write(f"from ._nxopen import *\n")

            with open(os.path.join(p11, "_nxopen.pyi"), "w", encoding="utf8") as f2:
                m2: nxoType
                f2.write("import NXOpen\n")
                f2.write("from typing import List\n")

                for k, v in mm.chdtps.items():
                    m2 = v
                    nn = m2.name
                    f2.write(f"from .clss.{nn} import {nn} as {nn}" + "\n")
                    with open(
                        os.path.join(p22, f"{nn}.pyi"), "w", encoding="utf8"
                    ) as f3:
                        f3.write("import NXOpen\n")
                        f3.write("from typing import List\n")
                        for _s in m2.toStr():
                            f3.write(f"{_s}\n")

if __name__ == "__main__":

    def main():
        mainModules().pyi()

    main()