Typehinting an extendable class

[ItsCubeTime]

Hi, I'm writing an html generator that uses Python classes to represent html elements.

I have a base class HtmlGen with several child classes, such as HtmlGen_Text, HtmlGen_Button, HtmlGen_Checkbox (etc).

An html structure is built like so:

h=HtmlGen()
h.text("some text")
h.checkbox(lambda newValueBool: print(f"checkbox switched to {newValueBool}"))
h.button(lambda: print("some python function that gets called on click")).text("some text inside the button")

Currently I implement this by creating the text/button/checkbox attributes inside HtmlGen.__init__(): ... (which all other classes inherit, allowing recursive use as demonstrated by me putting text inside the button on the last line in the snippet above).

My dilemma is now that I want to be able to create custom styling for each and every element type. To do this, I was thinking to allow subclassing of each child class, eg: class HtmlGen_PinkText(HtmlGen_Text): css=".p {color:pink;}", subclass HtmlGen: class HtmlGenExtended: def __init__(self): super().__init__(); self.pinkText=HtmlGen_PinkText and then do some magic inside the __new__ method to make sure all instances created from HtmlGenExtended via its attributes will inherit from HtmlGenExtended instead of HtmlGen.

The issue is, how could I then allow type hinting for syntax like he=HtmlGenExtended(); he.pinkText(...), without modifying the source code of the original HtmlGen? Is it possible at all? Any thoughts would be highly appreciated :) Currently all I can think of would be creating a build system that creates Python source code on the fly just for the type hinting (which would then have to copy every single class living as an attribute on HtmlGen, make them inherit from HtmlGenExtended instead & place them as attributes on a 3rd class used solemnly for type hinting alongside the attributes of HtmlGenExtended).

[erictraut]

I'm not sure I fully understand the proposed code structure, but it sounds like you want to leverage some form of polymorphism — i.e. functions that return different types depending on various context. The Python type system has several mechanisms to support polymorphism. One commonly-used tool is an overload, which you can read about here. Another available tool is generics — the use of type variables to represent stand-in types. You can read about generics here.

[erictraut]

That code crashes when I run it. In particular, there is no pinkText method on the object returned by he.button(...). I'm not sure how you intend for this to work. Could you give me a minimal example that doesn't crash?

You may find it useful to enable type checking. Use the popup menu in the bottom tool bar to tell pylance to set typeCheckingMode to "standard". By default, it's set to "off". Once enabled, pylance will statically analyze your code and tell you where there are static type violations — places where your code could crash at runtime.

[ItsCubeTime]

Could also be implemented using __getattr__, but here is one way using type(...):

from __future__ import annotations
import typing,types

class HtmlGen:
    types:dict[int,HtmlGen]=dict()
    def constructor(self, cls):
        h=(object.__hash__(cls)+object.__hash__(self.baseType)*100000000000)
        if typing.TYPE_CHECKING:
            return type(f"{cls.__name__}_BasedOn_{self.baseType.__name__}", (cls,self.baseType), dict()) # @note Perhaps pylance could be made to understand that a newly created type with 2 known bases (cls & self.baseType) should inherit its attributes?
        try: return HtmlGen.types[h]
        except: HtmlGen.types[h]=returnVal=type(f"{cls.__name__}_BasedOn_{self.baseType.__name__}", (cls,self.baseType), dict()); return returnVal
    def __init__(self):
        print("HtmlGen init")
        self.baseType=HtmlGen
        self.htmlGenSetAttributes()
    def htmlGenSetAttributes(self):
        self.text          = HtmlGen_Text if typing.TYPE_CHECKING else self.constructor(HtmlGen_Text)
        self.checkbox      = HtmlGen_Checkbox if typing.TYPE_CHECKING else self.constructor(HtmlGen_Checkbox)
        self.button        = HtmlGen_Button if typing.TYPE_CHECKING else self.constructor(HtmlGen_Button)
        self.horizontalList= HtmlGen_HorizontalList if typing.TYPE_CHECKING else self.constructor(HtmlGen_HorizontalList)


class HtmlGen_Text(): 
    def __init__(self) -> HtmlGen_Text: print("HtmlGen_Text init"); super().__init__()
class HtmlGen_Checkbox(): 
    def __init__(self) -> HtmlGen_Checkbox: super().__init__()
class HtmlGen_Button(): 
    def __init__(self,c:typing.Callable) -> HtmlGen_Button: super().__init__()
class HtmlGen_HorizontalList(): 
    def __init__(self) -> HtmlGen_HorizontalList: super().__init__()




class HtmlGenExtended(HtmlGen):
    def htmlGenSetAttributes(self):
        super().htmlGenSetAttributes()
        self.pinkText=HtmlGen_PinkText if typing.TYPE_CHECKING else self.constructor(HtmlGen_PinkText)
    def __init__(self):
        print("HtmlGenExtended init")
        self.baseType=HtmlGenExtended
        self.htmlGenSetAttributes()


class HtmlGen_PinkText(HtmlGen_Text):   # I realize I said HtmlGen_PinkText would inherit from HtmlGen_Text, 
                                        # I guess either is fine. I dont really care much for how I declare
                                        #  the classes  as long as I can get type hinting to work one way 
                                        # or another
    def __init__(self,t:str) -> HtmlGen_PinkText: print("HtmlGen_PinkText init"); super().__init__() 


he=HtmlGenExtended()
he.pinkText("") # @note Type hinting here would work just fine, as HtmlGenExtended has the pinkText attribute
he.button(lambda: print("pressed btn")).pinkText("") # @note But I also want type hinting here, where we're
                                                     # now accessing  `pinkText` of `HtmlGen_Button`, which was 
                                                     # originally declared only with `HtmlGen` as parent, which knows 
                                                     # nothing about `pinkText` at the time of its  declaration.
helist=he.horizontalList()
print("Creating pinkText")
hept=helist.pinkText("") # @note Ditto
print("Creating pinkText2")
hept2=he.pinkText("")
print(f"isinstance(he,HtmlGen): {isinstance(he,HtmlGen)}")
print(f"isinstance(hept,HtmlGen): {isinstance(hept,HtmlGen)}")
print(f"isinstance(hept,HtmlGenExtended): {isinstance(hept,HtmlGenExtended)}")
print(f"isinstance(hept,HtmlGen_Button): {isinstance(hept,HtmlGen_Button)}")
print(f"isinstance(hept,HtmlGen_Text): {isinstance(hept,HtmlGen_Text)}")
print(f"type(hept)==type(hept2): {type(hept)==type(hept2)}")

[ItsCubeTime]

@erictraut would it be possible for the following syntax to get supported? This would resolve my issue

class Cls1():
    attr1=1
class Cls2():
    attr2=2
class Cls3():
    attr3=3

def getCls(c,c2): # It is key that c1 & c2 are not type hinted here, as I would want to be able to call this function in different places, with different classes as arguments
    mergedType=type(f"{c.__name__}_MergedWith_{c2.__name__}", (c,c2), dict())
    return mergedType

print(getCls(Cls1,Cls2).attr1) # autocomplete for attributes of both Cls1 & Cls2
print(getCls(Cls1,Cls3).attr3) # autocomplete for attributes of both Cls1 & Cls3

getCls(Cls1,Cls2). # autocomplete for attributes of both Cls1 & Cls2
c4=getCls(Cls1,Cls3) 
c4. # autocomplete for attributes of both Cls1 & Cls3

Code completion with Pylance: v2025.6.1 with the Python VSCode plugin by MS v2025.8.0 - here I would like it to suggest "attr1" & "attr2". When typing a dot (.) after c4, I would like it to suggest "attr1" & "attr3":

[erictraut]

It might be possible to support this in the future if and when the Python static type system gains support for intersections. There is work underway within the Python typing community to support this, but it's a heavy lift. It's definitely not going to make it into Python 3.14, and 3.15 might even be a stretch.

def getCls[S, T](c: type[S], c2: type[T]) -> type[S & T]: ... # Here "&" represents an intersection, which isn't supported today

Even if/when intersections are introduced, highly dynamic programs (e.g. creating new classes on the fly at runtime) will typically not work well with static analysis tools. There are typically ways to avoid this by using more traditional tools in the language like multiple inheritance, generics, etc.

[ItsCubeTime]

Cool, sounds like that could do it, assuming brackets-before-parenthesis is equivalent to the following C++:

template <typename S, typename T>
void* getCls(const S& c, const T& c2) { // C++ cannot merge typical classes, hence the void* return type
    ...
}