comtypes 1.4.11__zip → 1.4.13__zip

comtypes-1.4.13/comtypes/test/test_util.py

@@ -0,0 +1,227 @@
+import unittest
+from ctypes import (
+    POINTER,
+    Structure,
+    Union,
+    addressof,
+    c_byte,
+    c_char,
+    c_double,
+    c_int,
+    c_void_p,
+    cast,
+    sizeof,
+)
+
+import comtypes.util
+from comtypes import GUID, CoCreateInstance, IUnknown, shelllink
+
+
+class ByrefAtTest(unittest.TestCase):
+    def test_ctypes(self):
+        for ctype, value in [
+            (c_int, 42),
+            (c_double, 3.14),
+            (c_char, b"A"),
+        ]:
+            with self.subTest(ctype=ctype, value=value):
+                obj = ctype(value)
+                # Test with zero offset - should point to the same location
+                ref = comtypes.util.byref_at(obj, 0)
+                ptr = cast(ref, POINTER(ctype))
+                # byref objects don't have contents, but we can cast them to pointers
+                self.assertEqual(addressof(ptr.contents), addressof(obj))
+                self.assertEqual(ptr.contents.value, value)
+
+    def test_array_offsets(self):
+        elms = [10, 20, 30, 40]
+        arr = (c_int * 4)(*elms)  # Create an array
+        # Test accessing different elements via offset
+        for i, expected in enumerate(elms):
+            with self.subTest(index=i, expected=expected):
+                ref = comtypes.util.byref_at(arr, offset=sizeof(c_int) * i)
+                ptr = cast(ref, POINTER(c_int))
+                self.assertEqual(ptr.contents.value, expected)
+
+    def test_pointer_arithmetic(self):
+        # Test that byref_at behaves like C pointer arithmetic
+
+        class TestStruct(Structure):
+            _fields_ = [
+                ("field1", c_int),
+                ("field2", c_double),
+                ("field3", c_char),
+            ]
+
+        struct = TestStruct(123, 3.14, b"X")
+        for fname, ftype, expected in [
+            ("field1", c_int, 123),
+            ("field2", c_double, 3.14),
+            ("field3", c_char, b"X"),
+        ]:
+            with self.subTest(field=fname, type=ftype, expected=expected):
+                offset = getattr(TestStruct, fname).offset
+                ref = comtypes.util.byref_at(struct, offset)
+                ptr = cast(ref, POINTER(ftype))
+                self.assertEqual(ptr.contents.value, expected)
+
+    def test_com_interface(self):
+        CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
+        sc = CoCreateInstance(CLSID_ShellLink, interface=shelllink.IShellLinkA)
+        ref = comtypes.util.byref_at(sc, 0)
+        ptr = cast(ref, POINTER(POINTER(IUnknown)))
+        self.assertEqual(addressof(ptr.contents), addressof(sc))
+
+    def test_large_offset(self):
+        # Create a large array to test with large offsets
+        arr = (c_int * 100)(*range(100))
+        # Test accessing element at index 50 (offset = 50 * sizeof(c_int))
+        offset = 50 * sizeof(c_int)
+        ref = comtypes.util.byref_at(arr, offset)
+        ptr = cast(ref, POINTER(c_int))
+        self.assertEqual(ptr.contents.value, 50)
+
+    def test_memory_safety(self):
+        for initial in [111, 222, 333, 444]:
+            with self.subTest(initial=initial):
+                obj = c_int(initial)
+                ref = comtypes.util.byref_at(obj, 0)
+                ptr = cast(ref, POINTER(c_int))
+                # Verify initial value
+                self.assertEqual(ptr.contents.value, initial)
+                # Modify original objects and verify references still work
+                obj.value = 333
+                # Verify reference still works after modification
+                self.assertEqual(ptr.contents.value, 333)
+
+
+class CastFieldTest(unittest.TestCase):
+    def test_ctypes(self):
+        class TestStruct(Structure):
+            _fields_ = [
+                ("int_field", c_int),
+                ("double_field", c_double),
+                ("char_field", c_char),
+            ]
+
+        struct = TestStruct(42, 3.14, b"X")
+        for fname, ftype, expected in [
+            ("int_field", c_int, 42),
+            ("double_field", c_double, 3.14),
+            ("char_field", c_char, b"X"),
+        ]:
+            with self.subTest(fname=fname, ftype=ftype):
+                actual = comtypes.util.cast_field(struct, fname, ftype)
+                self.assertEqual(actual, expected)
+
+    def test_type_reinterpretation(self):
+        class TestStruct(Structure):
+            _fields_ = [
+                ("data", c_int),
+            ]
+
+        # Create struct with known bit pattern
+        struct = TestStruct(0x41424344)  # ASCII "ABCD" in little-endian
+        # Cast the int field as a char array to see individual bytes
+        char_value = comtypes.util.cast_field(struct, "data", c_char)
+        # This should give us the first byte of the int
+        self.assertIsInstance(char_value, bytes)
+
+    def test_pointers(self):
+        class TestStruct(Structure):
+            _fields_ = [
+                ("ptr_field", c_void_p),
+                ("int_field", c_int),
+            ]
+
+        target_int = c_int(99)
+        struct = TestStruct(addressof(target_int), 123)
+        for fname, ftype, expected in [
+            ("ptr_field", c_void_p, addressof(target_int)),
+            ("int_field", c_int, 123),
+        ]:
+            with self.subTest(fname=fname, ftype=ftype, expected=expected):
+                actual_value = comtypes.util.cast_field(struct, fname, ftype)
+                self.assertEqual(actual_value, expected)
+
+    def test_nested_structures(self):
+        class InnerStruct(Structure):
+            _fields_ = [
+                ("inner_int", c_int),
+                ("inner_char", c_char),
+            ]
+
+        class OuterStruct(Structure):
+            _fields_ = [
+                ("outer_int", c_int),
+                ("inner", InnerStruct),
+            ]
+
+        inner = InnerStruct(456, b"Y")
+        outer = OuterStruct(789, inner)
+        # Cast the nested structure field
+        inner_value = comtypes.util.cast_field(outer, "inner", InnerStruct)
+        self.assertEqual(inner_value.inner_int, 456)
+        self.assertEqual(inner_value.inner_char, b"Y")
+        # Cast outer int field
+        outer_int = comtypes.util.cast_field(outer, "outer_int", c_int)
+        self.assertEqual(outer_int, 789)
+
+    def test_arrays(self):
+        class TestStruct(Structure):
+            _fields_ = [
+                ("int_array", c_int * 3),
+                ("single_int", c_int),
+            ]
+
+        arr = (c_int * 3)(10, 20, 30)
+        struct = TestStruct(arr, 40)
+        # Cast array field as array type
+        array_value = comtypes.util.cast_field(struct, "int_array", c_int * 3)
+        self.assertEqual(list(array_value), [10, 20, 30])
+        # Cast single int
+        int_value = comtypes.util.cast_field(struct, "single_int", c_int)
+        self.assertEqual(int_value, 40)
+
+    def test_union(self):
+        class TestUnion(Union):
+            _fields_ = [
+                ("as_int", c_int),
+                ("as_bytes", c_byte * 4),
+            ]
+
+        class TestStruct(Structure):
+            _fields_ = [
+                ("union_field", TestUnion),
+                ("regular_field", c_int),
+            ]
+
+        union_val = TestUnion()
+        union_val.as_int = 0x41424344  # "ABCD" in ASCII
+        struct = TestStruct(union_val, 999)
+        union_result = comtypes.util.cast_field(struct, "union_field", TestUnion)
+        self.assertEqual(union_result.as_int, 0x41424344)
+        int_result = comtypes.util.cast_field(struct, "regular_field", c_int)
+        self.assertEqual(int_result, 999)
+
+    def test_void_p(self):
+        class VTableLikeStruct(Structure):
+            _fields_ = [
+                ("QueryInterface", c_void_p),
+                ("AddRef", c_void_p),
+                ("Release", c_void_p),
+                ("custom_method", c_void_p),
+            ]
+
+        # Initialize with some dummy pointers
+        struct = VTableLikeStruct(0x1000, 0x2000, 0x3000, 0x4000)
+        # Test accessing different entries
+        for fname, expected in [
+            ("QueryInterface", 0x1000),
+            ("AddRef", 0x2000),
+            ("Release", 0x3000),
+            ("custom_method", 0x4000),
+        ]:
+            with self.subTest(fname=fname, expected=expected):
+                ptr_value = comtypes.util.cast_field(struct, fname, c_void_p)
+                self.assertEqual(ptr_value, expected)

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/test/test_variant.py

@@ -115,33 +115,52 @@ class VariantTestCase(unittest.TestCase):
         self.assertEqual(result, values)
 
     def test_pythonobjects(self):
-        if sys.version_info >= (3, 0):
-            objects = [None, 42, 3.14, True, False, "abc", "abc", 7]
-        else:
-            objects = [None, 42, 3.14, True, False, "abc", "abc", 7]
+        objects = [None, 42, 3.14, True, False, "abc", "abc", 7]
         for x in objects:
-            v = VARIANT(x)
-            self.assertEqual(x, v.value)
+            with self.subTest(x=x):
+                v = VARIANT(x)
+                self.assertEqual(x, v.value)
 
     def test_integers(self):
         v = VARIANT()
 
-        int_type = int if sys.version_info >= (3, 0) else (int, long)
-
-        if hasattr(sys, "maxint"):
-            # this test doesn't work in Python 3000
-            v.value = sys.maxsize
-            self.assertEqual(v.value, sys.maxsize)
-            self.assertIsInstance(v.value, int_type)
-
-            v.value += 1
-            self.assertEqual(v.value, sys.maxsize + 1)
-            self.assertIsInstance(v.value, int_type)
-
         v.value = 1
 
         self.assertEqual(v.value, 1)
-        self.assertIsInstance(v.value, int_type)
+        self.assertIsInstance(v.value, int)
+
+    def test_vt_uix_range_boundaries(self):
+        MIN_VT_I4 = -(2**31)
+        MAX_VT_I4 = 2**31 - 1
+        MAX_VT_UI4 = 2**32 - 1
+        MIN_VT_I8 = -(2**63)
+        MAX_VT_I8 = 2**63 - 1
+        MAX_VT_UI8 = 2**64 - 1
+        for val, vt in [
+            (MIN_VT_I8, VT_I8),
+            (MIN_VT_I4 - 1, VT_I8),
+            (MIN_VT_I4, VT_I4),
+            (0, VT_I4),
+            (MAX_VT_I4, VT_I4),
+            (MAX_VT_I4 + 1, VT_UI4),
+            (MAX_VT_UI4, VT_UI4),
+            (MAX_VT_UI4 + 1, VT_I8),
+            (MAX_VT_I8, VT_I8),
+            (MAX_VT_I8 + 1, VT_UI8),
+            (MAX_VT_UI8, VT_UI8),
+        ]:
+            with self.subTest(val=val, vt=vt):
+                v = VARIANT()
+                v.value = val
+                self.assertEqual(v.value, val)
+                self.assertEqual(v.vt, vt)
+
+    def test_out_of_vt_uix_range(self):
+        MIN_VT_I8 = -(2**63)
+        MAX_VT_UI8 = 2**64 - 1
+        for val in [MIN_VT_I8 - 1, MAX_VT_UI8 + 1]:
+            with self.subTest(val=val), self.assertRaises(TypeError):
+                VARIANT().value = val
 
     def test_datetime(self):
         now = datetime.datetime.now()
@@ -304,13 +323,11 @@ def check_perf(rep=20000):
     by_var = byref(variable)
     ptr_var = pointer(variable)
 
-    if sys.version_info >= (3, 0):
-        import pickle
-    else:
-        import cPickle as pickle
+    import pickle
+
     try:
         previous = pickle.load(open("result.pickle", "rb"))
-    except IOError:
+    except OSError:
         previous = {}
 
     results = {}

comtypes-1.4.13/comtypes/test/test_viewobject.py

@@ -0,0 +1,78 @@
+import contextlib
+import unittest
+from ctypes.wintypes import POINT, RECT, SIZEL
+
+import comtypes.client
+from comtypes import IUnknown
+from comtypes.viewobject import (
+    DVASPECT_CONTENT,
+    IAdviseSink,
+    IViewObject,
+    IViewObject2,
+    IViewObjectEx,
+)
+
+with contextlib.redirect_stdout(None):  # supress warnings
+    comtypes.client.GetModule("mshtml.tlb")
+
+import comtypes.gen.MSHTML as mshtml
+
+
+def create_html_document() -> IUnknown:
+    return comtypes.client.CreateObject(mshtml.HTMLDocument)
+
+
+class Test_IViewObject(unittest.TestCase):
+    def test_Advise_GetAdvise(self):
+        vo = create_html_document().QueryInterface(IViewObject)
+        # Test that we can clear any existing advise connection.
+        vo.SetAdvise(DVASPECT_CONTENT, 0, None)
+        # Verify that no advise connection is present.
+        aspect, advf, sink = vo.GetAdvise()
+        self.assertIsInstance(aspect, int)
+        self.assertIsInstance(advf, int)
+        self.assertIsInstance(sink, IAdviseSink)
+        self.assertFalse(sink)  # A NULL com pointer evaluates to False.
+
+    def test_Freeze_Unfreeze(self):
+        vo = create_html_document().QueryInterface(IViewObject)
+        cookie = vo.Freeze(DVASPECT_CONTENT, -1, None)
+        self.assertIsInstance(cookie, int)
+        vo.Unfreeze(cookie)
+
+
+class Test_IViewObject2(unittest.TestCase):
+    def test_GetExtent(self):
+        vo = create_html_document().QueryInterface(IViewObject2)
+        size = vo.GetExtent(DVASPECT_CONTENT, -1, None)
+        self.assertTrue(size)
+        self.assertIsInstance(size, SIZEL)
+
+
+class Test_IViewObjectEx(unittest.TestCase):
+    def test_GetRect(self):
+        vo = create_html_document().QueryInterface(IViewObjectEx)
+        rect = vo.GetRect(DVASPECT_CONTENT)
+        self.assertTrue(rect)
+        self.assertIsInstance(rect, RECT)
+
+    def test_GetViewStatus(self):
+        vo = create_html_document().QueryInterface(IViewObjectEx)
+        status = vo.GetViewStatus()
+        self.assertIsInstance(status, int)
+
+    def test_QueryHitPoint(self):
+        vo = create_html_document().QueryInterface(IViewObjectEx)
+        # It is assumed that the view is not transparent at the origin.
+        bounds = RECT(left=0, top=0, right=100, bottom=100)
+        loc = POINT(x=0, y=0)
+        hit = vo.QueryHitPoint(DVASPECT_CONTENT, bounds, loc, 0)
+        self.assertIsInstance(hit, int)
+
+    def test_QueryHitRect(self):
+        vo = create_html_document().QueryInterface(IViewObjectEx)
+        # It is assumed that the view is not transparent at the origin.
+        bounds = RECT(left=0, top=0, right=100, bottom=100)
+        loc = RECT(left=0, top=0, right=1, bottom=1)
+        hit = vo.QueryHitRect(DVASPECT_CONTENT, bounds, loc, 0)
+        self.assertIsInstance(hit, int)

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/test/test_word.py

@@ -26,7 +26,7 @@ except (ImportError, OSError):
 ################################################################
 
 
-class _Sink(object):
+class _Sink:
     def __init__(self):
         self.events = []
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/codegenerator.py

@@ -42,7 +42,7 @@ _InterfaceTypeDesc = _UnionT[
 ]
 
 
-class CodeGenerator(object):
+class CodeGenerator:
     def __init__(self, known_symbols=None, known_interfaces=None) -> None:
         self.stream = io.StringIO()
         self.imports = namespaces.ImportedNamespaces()

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/comments.py

@@ -3,7 +3,7 @@ import io
 from comtypes.tools import typedesc
 
 
-class ComInterfaceBodyImplCommentWriter(object):
+class ComInterfaceBodyImplCommentWriter:
     def __init__(self, stream: io.StringIO):
         self.stream = stream
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/heads.py

@@ -13,7 +13,7 @@ def _to_docstring(orig: str, depth: int = 1) -> str:
     return f'{indent}"""{repled}"""'
 
 
-class StructureHeadWriter(object):
+class StructureHeadWriter:
     def __init__(self, stream: io.StringIO) -> None:
         self.stream = stream
 
@@ -67,7 +67,7 @@ class StructureHeadWriter(object):
                 print("    pass", file=self.stream)
 
 
-class LibraryHeadWriter(object):
+class LibraryHeadWriter:
     def __init__(self, stream: io.StringIO) -> None:
         self.stream = stream
 
@@ -93,7 +93,7 @@ class LibraryHeadWriter(object):
         )
 
 
-class CoClassHeadWriter(object):
+class CoClassHeadWriter:
     def __init__(self, stream: io.StringIO, filename: Optional[str]) -> None:
         self.stream = stream
         self.filename = filename
@@ -117,7 +117,7 @@ class CoClassHeadWriter(object):
         )
 
 
-class ComInterfaceHeadWriter(object):
+class ComInterfaceHeadWriter:
     def __init__(self, stream: io.StringIO) -> None:
         self.stream = stream
 
@@ -172,7 +172,7 @@ class ComInterfaceHeadWriter(object):
             print(annotations, file=self.stream)
 
 
-class DispInterfaceHeadWriter(object):
+class DispInterfaceHeadWriter:
     def __init__(self, stream: io.StringIO) -> None:
         self.stream = stream
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/helpers.py

@@ -6,7 +6,7 @@ from comtypes.tools import typedesc
 from comtypes.tools.codegenerator.modulenamer import name_wrapper_module
 
 
-class lcid(object):
+class lcid:
     def __repr__(self):
         return "_lcid"
 
@@ -14,7 +14,7 @@ class lcid(object):
 lcid = lcid()
 
 
-class dispid(object):
+class dispid:
     def __init__(self, memid):
         self.memid = memid
 
@@ -22,7 +22,7 @@ class dispid(object):
         return f"dispid({self.memid})"
 
 
-class helpstring(object):
+class helpstring:
     def __init__(self, text):
         self.text = text
 
@@ -100,7 +100,7 @@ def _to_arg_definition(
     return code
 
 
-class ComMethodGenerator(object):
+class ComMethodGenerator:
     def __init__(self, m: typedesc.ComMethod, isdual: bool) -> None:
         self._m = m
         self._isdual = isdual
@@ -208,7 +208,7 @@ class ComMethodGenerator(object):
             yield (type_name, arg_name, idlflags, default)
 
 
-class DispMethodGenerator(object):
+class DispMethodGenerator:
     def __init__(self, m: typedesc.DispMethod) -> None:
         self._m = m
         self.data: List[str] = []
@@ -262,7 +262,7 @@ class DispMethodGenerator(object):
             yield (type_name, arg_name, idlflags, default)
 
 
-class DispPropertyGenerator(object):
+class DispPropertyGenerator:
     def __init__(self, m: typedesc.DispProperty) -> None:
         self._m = m
         self._to_type_name = TypeNamer()
@@ -290,7 +290,7 @@ class DispPropertyGenerator(object):
         return (idlflags, type_name, self._m.name)
 
 
-class TypeNamer(object):
+class TypeNamer:
     def __call__(self, t: Any) -> str:
         # Return a string, containing an expression which can be used
         # to refer to the type. Assumes the 'from ctypes import *'

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/namespaces.py

@@ -15,7 +15,7 @@ from typing import (
 from typing import Union as _UnionT
 
 
-class ImportedNamespaces(object):
+class ImportedNamespaces:
     def __init__(self) -> None:
         self.data: Dict[str, Optional[str]] = {}
 
@@ -132,7 +132,7 @@ class ImportedNamespaces(object):
         return "\n".join(lines)
 
 
-class DeclaredNamespaces(object):
+class DeclaredNamespaces:
     def __init__(self) -> None:
         self.data: Dict[Tuple[str, str], Optional[str]] = {}
 
@@ -168,7 +168,7 @@ class DeclaredNamespaces(object):
         return "\n".join(lines)
 
 
-class EnumerationNamespaces(object):
+class EnumerationNamespaces:
     def __init__(self) -> None:
         self.data: Dict[str, List[Tuple[str, int]]] = {}
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/codegenerator/typeannotator.py

@@ -276,7 +276,7 @@ class ComMethodsAnnotator(_MethodsAnnotator[typedesc.ComMethod]):
         return ComMethodAnnotator(m)
 
 
-class ComInterfaceMembersAnnotator(object):
+class ComInterfaceMembersAnnotator:
     def __init__(self, itf: typedesc.ComInterface):
         self.itf = itf
 
@@ -316,7 +316,7 @@ class DispMethodsAnnotator(_MethodsAnnotator[typedesc.DispMethod]):
         return DispMethodAnnotator(m)
 
 
-class DispInterfaceMembersAnnotator(object):
+class DispInterfaceMembersAnnotator:
     def __init__(self, itf: typedesc.DispInterface):
         self.itf = itf
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/tlbparser.py

@@ -108,7 +108,7 @@ COMTYPES = {
 ################################################################
 
 
-class Parser(object):
+class Parser:
     tlib: typeinfo.ITypeLib
     items: Dict[str, Any]
 

{comtypes-1.4.11 → comtypes-1.4.13}/comtypes/tools/typedesc.py

@@ -10,7 +10,7 @@ from comtypes.tools.typedesc_base import *
 from comtypes.typeinfo import TLIBATTR, ITypeLib
 
 
-class TypeLib(object):
+class TypeLib:
     def __init__(
         self, name: str, guid: str, major: int, minor: int, doc: Optional[str] = None
     ) -> None:
@@ -24,7 +24,7 @@ class TypeLib(object):
         return f"<TypeLib({self.name}: {self.guid}, {self.major}, {self.minor})>"
 
 
-class Constant(object):
+class Constant:
     def __init__(
         self,
         name: str,
@@ -38,7 +38,7 @@ class Constant(object):
         self.doc = doc
 
 
-class External(object):
+class External:
     def __init__(
         self,
         tlib: ITypeLib,
@@ -61,13 +61,13 @@ class External(object):
         return self
 
 
-class SAFEARRAYType(object):
+class SAFEARRAYType:
     def __init__(self, typ: Any) -> None:
         self.typ = typ
         self.align = self.size = ctypes.sizeof(ctypes.c_void_p) * 8
 
 
-class ComMethod(object):
+class ComMethod:
     # custom COM method, parsed from typelib
     def __init__(
         self,
@@ -92,7 +92,7 @@ class ComMethod(object):
         self.arguments.append((typ, name, idlflags, default))
 
 
-class DispMethod(object):
+class DispMethod:
     # dispatchable COM method, parsed from typelib
     def __init__(
         self,
@@ -117,7 +117,7 @@ class DispMethod(object):
         self.arguments.append((typ, name, idlflags, default))
 
 
-class DispProperty(object):
+class DispProperty:
     # dispatchable COM property, parsed from typelib
     def __init__(
         self, dispid: int, name: str, typ: Any, idlflags: List[str], doc: Optional[Any]
@@ -129,17 +129,17 @@ class DispProperty(object):
         self.doc = doc
 
 
-class DispInterfaceHead(object):
+class DispInterfaceHead:
     def __init__(self, itf: "DispInterface") -> None:
         self.itf = itf
 
 
-class DispInterfaceBody(object):
+class DispInterfaceBody:
     def __init__(self, itf: "DispInterface") -> None:
         self.itf = itf
 
 
-class DispInterface(object):
+class DispInterface:
     def __init__(
         self,
         name: str,
@@ -167,17 +167,17 @@ class DispInterface(object):
         return self.itf_head
 
 
-class ComInterfaceHead(object):
+class ComInterfaceHead:
     def __init__(self, itf: "ComInterface") -> None:
         self.itf = itf
 
 
-class ComInterfaceBody(object):
+class ComInterfaceBody:
     def __init__(self, itf: "ComInterface") -> None:
         self.itf = itf
 
 
-class ComInterface(object):
+class ComInterface:
     def __init__(
         self,
         name: str,
@@ -209,7 +209,7 @@ _ImplTypeFlags = int
 _Interface = _UnionT[ComInterface, DispInterface]
 
 
-class CoClass(object):
+class CoClass:
     def __init__(
         self,
         name: str,