I suppose how it can be check what type specified on Generic types in __init__ ? On python 3.10, it could not be. On first, I found this page: Instantiate a type that is a TypeVar and make some utility for get __orig_class__. And test on instancing time, there is no __orig_class__ attribute in that timing on self. Then I searched again I found this issue page: https://github.com/python/typing/issues/658. I recognized that any python might have this limit. Is there any other way? The following is sample code (not original one). This code cannot be executed for the reasons stated above. (I haven't run it, so there may be some bugs too.) from abc import ABC, abstractmethod from typing import Iterable, Any, TypeVar, Generic class BaseLoader(ABC): """ `BaseLoader` loads something and return some expected object. - load a file from path(str) - convert a raw data to some expected data (list like) - implement `load` in inherited class. """ def __init__(self, path: str): self._path = path @abstractmethod def load(self) -> Iterable: pass class SimpleLineLoader(BaseLoader): """ `SimpleTextBaseLoader` loads text data and return some converted lines. - load a utf-8 text file. - convert to a list of text lines. - implement `_convert_line` in inherited class. """ def load(self): with open(self._path, "r") as f: lines = f.readlines() converted_lines = [self._convert_line(line) for line in lines] return converted_lines @abstractmethod def _convert_line(self, line: str) -> Any: """ `_convert_line` convert line string to another one. """ pass class RawLineLoader(SimpleLineLoader): """ `RawLineLoader` loads raw data. nothing to do. """ def _convert_line(self, line): """ nothing to do. just return raw value. """ return line class ElementTrimmedLineLoader(SimpleLineLoader): """ `ElementTrimmedLineLoader` loads lines and regards each line as comma(,) separated data. it trims each tokens in the line and get back to the line. - trims each element separated with comma in each line. - sample: >>> from tempfile import TemporaryDirectory >>> data = ["a, b, d ", "d , e , f"] >>> with TemporaryDirectory() as dname: >>> with open(dname, "w") as f: >>> f.writelines(data) >>> loader = ElementTrimmedLineLoader(f.name) >>> print(loader.load()) [['a', 'b', 'd'], ['d', 'e', 'f']] """ def __init__(self, path): super().__init__(path) self._delim = "," def _convert_line(self, line): """ split with the delim and trim each element, combine them to one with the delim again. """ delim = self._delim converted = delim.join(elem.strip(' ') for elem in line.split(delim)) return converted def get_delim(self): """ get a delimiter in use """ return self._delim class BaseProcessor(ABC): """ `BaseProcessor` process `Iterable` and return a list of result of `_process_element`. - implement `_process_element` in inherited class. """ def __init__(self, loader: BaseLoader, another_param: object): self._loader = loader self._another_param = another_param def process(self, elements: Iterable) -> list[Any]: data = self._loader.load() result = [] for element in data: output = self._process_element(element) result.append(output) # print(output) return result @abstractmethod def _process_element(self, element: object) -> Any: pass options = {filename: "c:/some/constant/path.txt"} T = TypeVar(T, bound=BaseLoader) class SimpleBaseProcessor(BaseProcessor, Generic[T]): """ `SimpleBaseProcessor` process a constant file, and return raw values in situ. - indicate `BaseLoader` class. (what data is expected as prerequisite) - override `_process_element` in inherited class. """ def __init__(self, another_param: object): loader_class = self.__orig_class__.__args__[0] loader = loader_class(options["filename"]) super().__init__(loader, another_param) def _process_element(self, element): """ nothing to do. just return raw value. (default) """ return element class LineCountPrefixedProcessor(SimpleBaseProcessor[RawLineLoader]): """ `LineCountPrefixedProcessor` return a list of line count prefixed line strings. """ def __init__(self, another_param, prefix = "{0} | "): super().__init__(another_param) self._prefix = prefix self._count = 0 def _process_element(self, element): processed = self._prefix.format(self._count) + element self._count += 1 return processed class ElementQuoteProcessor(SimpleBaseProcessor[ElementTrimmedLineLoader]): """ `ElementQuoteProcessor` process trimmed elements and quote each of them. """ def __init__(self, another_param, quote_char = "'"): super().__init__(another_param) self._quote_char = quote_char def _quote(self, target): q = self._quote return q + target + q def _process_element(self, element): delim = self._loader.get_delim() return delim.join(self._quote(elem) for elem in element.split(delim)) 
When you write something like: from typing import Generic, TypeVar T = TypeVar('T') class MyGeneric(Generic[T]): def __init__(self): print(getattr(self, '__orig_class__', None)) x = MyGeneric[int]()  You may see x.orig_class appear on some Python versions and not on others. That is an internal artifact of how the CPython interpreter (and the typing module) tracked Generic information in older versions. It was never specified in any PEP as a stable, user-facing API for “inspect your type parameters at runtime.” Since standard Python discards generic parameters at runtime, why not just store them yourself from typing import Generic, TypeVar, Type T = TypeVar('T') class MyGenericClass(Generic[T]): def __init__(self, t: Type[T]): self._t = t x - MyGenericClass(int) print(x._t)  Or just pass the value class MyGenericClass(Generic[T]): def __init(self, examplevalue: T): self._t = type(examplevalue) 