Next Gen stubs

[CEXT-Dan]

I made a prototype of function overloading. Need to implement it.

[CEXT-Dan]

should be...
Additional Args:
or
Overloads:

[gswifort]

Meybe @typing.overload

[CEXT-Dan]

That’s the one!

I have to write them all by hand, so it’s going to take a minute.
VS Code won’t read what boost::python emits. There’s not a whole lot of them
Hoping to get the constructors first and commonly used functions first

[gswifort]

I don't know how boost::python works, but I see that many methods have stubs - were they generated automatically by boost::python or by you?
Do you have any influence on how methods are generated in *.pyi or is everything automatically generated?
If it's not possible to customize how boost::python works, you can probably always parse the generated *.pyi file and add docstring-based methods:

class ArcDimension:
    def __init__ (self, *args, **kwargs)-> None :
      '''__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(struct _object * __ptr64)

__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(struct _object * __ptr64)

__init__( (object)arg1, (ObjectId)arg2) -> None :

    C++ signature :
        void __init__(struct _object * __ptr64,class PyDbObjectId)

__init__( (object)arg1, (ObjectId)arg2, (OpenMode)arg3) -> None :

    C++ signature :
        void __init__(struct _object * __ptr64,class PyDbObjectId,enum AcDb::OpenMode)'''

##########################

class ArcDimension:
    @overload
    def __init__(self, /) -> None : ...

    @overload
    def __init__(self, arg1: ObjectId, /) -> None : ...
    
    @overload
    def __init__(self, arg1: ObjectId, arg2: OpenMode, /) -> None : ...

    def __init__ (self, *args, **kwargs)-> None : ...

the docstrings do not provide the names of the method parameters, I assume it is not arg1, arg2, arg3 etc., that's why I used positional-only parameters

[CEXT-Dan]

I have a stub generator, what you posted generated from boost’s docstring, without modification
I’ve been inserting named parameters into the docstring to generate a more correct stub

I just learned about the @overload, so I’m doing exactly what you suggest, parsing that docstring
I insert the named parameters into the docstring from the C++ side. Then parse it.

I’ll go through and do all the constructors first.

this is the output of Db.Text.... getting close : )

class Text:

    @overload
    def __init__ (self, /)-> None :
        ...

    @overload
    def __init__ (self, position: PyGe.Point3d, text: str)-> None :
        ...

    @overload
    def __init__ (self, position: PyGe.Point3d, text: str, height: float, rotation: float)-> None :
        ...

    @overload
    def __init__ (self, id: PyDb.ObjectId)-> None :
        ...

    @overload
    def __init__ (self, id: PyDb.ObjectId, mode: PyDb.OpenMode)-> None :
        ...

    @overload
    def __init__ (self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool)-> None :
        ...
    def __init__ (self)-> None :
      '''Overloads:
    - None: Any
    - position: PyGe.Point3d, text: str
    - position: PyGe.Point3d, text: str, height: float, rotation: float
    - id: PyDb.ObjectId
    - id: PyDb.ObjectId, mode: PyDb.OpenMode
    - id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool
    '''
    ...

[gswifort]

I see that in each class you define all methods, including inherited ones:

class Entity(DbObject):
    def addReactor (self, reactor: PyDb.EntityReactor)-> None :
        ...

class Curve(Entity):
    def addReactor (self, reactor: PyDb.EntityReactor)-> None :
        ...

class Line(Curve):
    def addReactor (self, reactor: PyDb.EntityReactor)-> None :
        ...

it is enough only in the first class:

class Entity(DbObject):
    def addReactor (self, reactor: PyDb.EntityReactor)-> None :
        ...

class Curve(Entity):
        ...

class Line(Curve):
        ...

[CEXT-Dan]

Yes, but not on purpose. The doc string generator is a total hack, I started rolling it when I knew zero python and now it’s morphed onto a mess lol

Using inspect
for each class in module
--for each method in class
----make docstring from the C++ signature

Gives every method. A small number are actually virtual overrides from a C++ perspective.
This will definitely be one of the areas that's worked on when I refactor

is it causing an issue?

[gswifort]

It does not cause problems, but it is good to know where a given method is defined - whether it is the same for all Entity or, for example, the Line class has a different implementation.
I understand you are talking about the genDoc.py module? Maybe I can suggest solutions.

[CEXT-Dan]

I figured it was a side affect of boost Boost generates a docstring like”

“setDatabaseDefaults( (Entity)arg1) -> None :
    C++ signature :
        void setDatabaseDefaults(class PyDbEntity {lvalue})
setDatabaseDefaults( (Entity)arg1, (Database)arg2) -> None :
    ![(self, db: PyDb.Database = 'current')]!<[{4351}]>
    C++ signature :
        void setDatabaseDefaults(class PyDbEntity {lvalue},class PyDbDatabase)”

I inject stuff from the C++ side, I.e.

![(self, db: PyDb.Database = 'current')]!<[{4351}]>

and parse it

BTW, someone on the boost::python team is supposedly working on compliant stubs.
So I had intended to refactor at some point.

[gswifort]

If a given function doesn't have a docstring id assigned (![(self)]!<[{-1}]>), can I simply search DocStrings.json by the name Db.BlockTableRecord.blockScaling → acdbblocktablerecord__blockscaling? I know that wrapper classes aren't always named the same as the original classes, but maybe it's easier to create a file mapping wrapper names to original names than assigning an id to each function?

[CEXT-Dan]

-1 means I have not assigned it yet, eventually they will all have IDs assigned.
I have an SQLIte database (DocString.db) that I use to store the docstrings, then I export it to JSON. The number is the ROWID

Exporting to JSON is a workaround because SQLite wont load into BricsCAD due to a binary conflict and I need to be able to generate stubs from that platform. I’m considering changing to duckdb and removing the need for the JSON, just make the query

For now, the process is, if an item does not have a docstring, add it to the database, export the table to Jason (SQLiteStudio)
Add the entry to the CPP file

I.e. from

.def("blockScaling", &PyDbBlockTableRecord::blockScaling, DS.ARGS())
.def("setBlockScaling", &PyDbBlockTableRecord::setBlockScaling, DS.ARGS({ "val : PyDb.BlockScaling" }))

To:

.def("blockScaling", &PyDbBlockTableRecord::blockScaling, DS.ARGS(XXXX))
.def("setBlockScaling", &PyDbBlockTableRecord::setBlockScaling, DS.ARGS({ "val : PyDb.BlockScaling" },XXXX))

If it’s in the JSON file, it’s already in the database, so it just needs the number assigned.
There’s probably a thousand or so to do… I usually do these when my brain is toast and I just do busy work

[gswifort]

Hi, I worked a bit on the stubs.
In my opinion they are almost perfect :)
I have to refactor the generating code a bit, but I'm uploading the generated files.
Please correct a few detected errors:

PyAp.Document: def setUserData(self, data: any, /): ... 
                                           ^^^

PyEd.Editor: def ssget(mode: str, arg1: any, arg2: any, filter: list = None, /):
                                        ^^^        ^^^

PyPl.PlotFactory: def createPreviewEngine(flags: int = default, /) -> PyPl.PlotEngine: ... 
                                                       ^^^^^^^

PyGi.Geometry: def circularArc(self, p1: PyGe.Point3d, p2: PyGe.Point3d, p3: PyGe.Point3d, arcType: PyGe.ArcType, /)
                                                                                                    ^^^^^^^^^^^^ (PyGe.ArcType ?)
                                                                                                                  
PyGi.Geometry: def polyline(self, vertexList, normal: PyGe.Vector3d = default, marker: int = default, /) -> bool:
                                                                      ^^^^^^^                ^^^^^^^
                                                                                                                  
PyDb.ArcDimension: def __init__( self, centerPoint: PyGe.point3d, xLine1Point: PyGe.Point3d, xLine2Point: PyGe.Point3d, arcPnt: PyGe.Point3d, /): ...
                                                         ^^^^^^^

PyDb.DiametricDimension: def __init__(self, chordPoint: PyGe.point3d, farChordPoint: PyGe.Point3d, leaderLength: float, /): ...
                                                             ^^^^^^^

PyDb.Point3AngularDimension: def __init__(self, centerPoint: PyGe.point3d, xL1Start: PyGe.Point3d, xL1End: PyGe.Point3d, arcPnt: PyGe.Point3d, /): ...
                                                                  ^^^^^^^

PyDb.BlockReference: def appendAttribute(self, val: PyDb.Attribute, /) -> PyDb.ObjectId:
                                                    ^^^^^^^^^^^^^^ (AttributeReference)

PyDb.Core: def getReservedString(reservedType: PyDb.reservedStringEnumType, bGetLocalized: bool, /) -> str:
                                               ^^^^^^^^^^^ (PyDb.ReservedStringEnumType)

           def isReservedString(val: str, reservedType: PyDb.reservedStringEnumType, /) -> bool:
                                                        ^^^^^^^^^^^ (PyDb.ReservedStringEnumType)

PyDb.DimStyleTableRecord: def arrowId(self, val: PyDb.DimArrowFlags, /) -> PyDb.ObjectId: ...
                                                 ^^^^^^^^^^^^^^^^^^ ?????

PyDb.Polyline3d: def appendVertex(self, vertex: PyDb.Vertex3d, /): ...
                                                ^^^^^^^^^^^^^ PyDb.Vertex ??

PyDb.Polyline3d: def insertVertexAt(self, indexVt: PyDb.Vertex3d, newVertex: PyDb.Vertex3d, /): ...
                                                   ^^^^^^^^^^^^^ PyDb.Vertex ??


PyDb.Table: def setFieldId(self, row: int, col: int, content: int, id: PyDb.ObjectId, nFlag: PyDb.CellOption, /): ...
                                                                                             ^^^^^^^^^^^^^^^ CellProperty ??

PyDb.Table: def setGridLineStyle(self, row: int, col: int, nGridLineType: PyDb.GridLineTypes, nLineStyle: PyDb.GridLineStyle, /): ...
                                                                          ^^^^^^^^^^^^^^^^^^ PyDb.GridLineType (without "s")

PyDb.Table: def setGridLinetype(self, row: int, col: int, nGridLineType: PyDb.GridLineTypes, idLinetype: PyDb.ObjectId, /): ...
                                                                         ^^^^^^^^^^^^^^^^^^ PyDb.GridLineType (without "s")
PyGs.GsView: def setView (self, pos: PyGe.Point3d, target: PyGe.Point3d, upVector: PyGe.Vector3d, fWidth: float, fHeight: float,  PyGs.Projection = kParallel)-> None :
                                                                                                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

stubs.zip

[gswifort]

5ac65be

https://github.com/CEXT-Dan/PyRx/blob/main/PyRxCore%2FPyGsView.cpp#L97

argument name is missing

[CEXT-Dan]

thanks, I had missed a couple of enums, I've added them

[gswifort]

https://github.com/CEXT-Dan/PyRx/blob/main/PyRxCore%2FPyGsView.cpp#L97

PyGs.ViewProjection = PyGs.ViewProjection.kParallel

type hints and default value provided, but argument name missing

[CEXT-Dan]

I noticed there's some activity with boost::python's signatures and doc strings. I'll have a look when I get back