Python types.new_class() Examples
The following are 30
code examples of types.new_class().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
types
, or try the search function
.

Example #1
Source Project: edgedb Author: edgedb File: commondl.py License: Apache License 2.0 | 6 votes |
def _new_nonterm(self, clsname, clsdict=None, clskwds=None, clsbases=(Nonterm,)): if clsdict is None: clsdict = {} if clskwds is None: clskwds = {} mod = sys.modules[self.name] def clsexec(ns): ns['__module__'] = self.name for k, v in clsdict.items(): ns[k] = v return ns cls = types.new_class(clsname, clsbases, clskwds, clsexec) setattr(mod, clsname, cls) return cls
Example #2
Source Project: pymtl3 Author: pymtl File: bitstructs.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def mk_bitstruct( cls_name, fields, *, namespace=None, add_init=True, add_str=True, add_repr=True, add_hash=True ): # copy namespace since will mutate it namespace = {} if namespace is None else namespace.copy() # We assume fields is a dictionary and thus there won't be duplicate # field names. So we only check if the field names are indeed strings # and that they are not keywords. annos = {} for name, f in fields.items(): if not isinstance( name, str ) or not name.isidentifier(): raise TypeError( f'Field name {name!r} is not a valid identifier!' ) if keyword.iskeyword( name ): raise TypeError( f'Field name {name!r} is a keyword!' ) annos[ name ] = f namespace['__annotations__'] = annos cls = types.new_class( cls_name, (), {}, lambda ns: ns.update( namespace ) ) return bitstruct( cls, add_init=add_init, add_str=add_str, add_repr=add_repr, add_hash=add_hash )
Example #3
Source Project: simpledet Author: TuSimple File: patch_config.py License: Apache License 2.0 | 6 votes |
def patch_config_as_nothrow(instance): if "NoThrow" in [instance.__name__, instance.__class__.__name__]: return instance if type(instance) == type: instance = types.new_class(instance.__name__ + "NoThrow", (instance, ), dict(metaclass=NoThrowMeta)) for (k, v) in inspect.getmembers(instance): if not k.startswith("__") and type(v) == type: type.__setattr__(instance, k, patch_config_as_nothrow(v)) else: for (k, v) in inspect.getmembers(instance.__class__): if not k.startswith("__") and type(v) == type: type.__setattr__(instance.__class__, k, patch_config_as_nothrow(v)) instance.__class__ = type(instance.__class__.__name__ + "NoThrow", (instance.__class__, NoThrowBase), {}) return instance
Example #4
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 6 votes |
def test_prepare_class(self): # Basic test of metaclass derivation expected_ns = {} class A(type): def __new__(*args, **kwargs): return type.__new__(*args, **kwargs) def __prepare__(*args): return expected_ns B = types.new_class("B", (object,)) C = types.new_class("C", (object,), {"metaclass": A}) # The most derived metaclass of D is A rather than type. meta, ns, kwds = types.prepare_class("D", (B, C), {"metaclass": type}) self.assertIs(meta, A) self.assertIs(ns, expected_ns) self.assertEqual(len(kwds), 0)
Example #5
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 6 votes |
def test_metaclass_override_function(self): # Special case: the given metaclass isn't a class, # so there is no metaclass calculation. class A(metaclass=self.Meta): pass marker = object() def func(*args, **kwargs): return marker X = types.new_class("X", (), {"metaclass": func}) Y = types.new_class("Y", (object,), {"metaclass": func}) Z = types.new_class("Z", (A,), {"metaclass": func}) self.assertIs(marker, X) self.assertIs(marker, Y) self.assertIs(marker, Z)
Example #6
Source Project: Fluid-Designer Author: Microvellum File: util.py License: GNU General Public License v3.0 | 6 votes |
def specialize_class(cls, kind, base=None, **kwargs): # XXX Support passing in submodule names--load (and cache) them? # That would clean up the test modules a bit more. if base is None: base = unittest.TestCase elif not isinstance(base, type): base = base[kind] name = '{}_{}'.format(kind, cls.__name__) bases = (cls, base) specialized = types.new_class(name, bases) specialized.__module__ = cls.__module__ specialized._NAME = cls.__name__ specialized._KIND = kind for attr, values in kwargs.items(): value = values[kind] setattr(specialized, attr, value) return specialized
Example #7
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 6 votes |
def test_prepare_class(self): # Basic test of metaclass derivation expected_ns = {} class A(type): def __new__(*args, **kwargs): return type.__new__(*args, **kwargs) def __prepare__(*args): return expected_ns B = types.new_class("B", (object,)) C = types.new_class("C", (object,), {"metaclass": A}) # The most derived metaclass of D is A rather than type. meta, ns, kwds = types.prepare_class("D", (B, C), {"metaclass": type}) self.assertIs(meta, A) self.assertIs(ns, expected_ns) self.assertEqual(len(kwds), 0)
Example #8
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 6 votes |
def test_metaclass_override_function(self): # Special case: the given metaclass isn't a class, # so there is no metaclass calculation. class A(metaclass=self.Meta): pass marker = object() def func(*args, **kwargs): return marker X = types.new_class("X", (), {"metaclass": func}) Y = types.new_class("Y", (object,), {"metaclass": func}) Z = types.new_class("Z", (A,), {"metaclass": func}) self.assertIs(marker, X) self.assertIs(marker, Y) self.assertIs(marker, Z)
Example #9
Source Project: ray Author: ray-project File: cloudpickle.py License: Apache License 2.0 | 6 votes |
def _make_skeleton_class(type_constructor, name, bases, type_kwargs, class_tracker_id, extra): """Build dynamic class with an empty __dict__ to be filled once memoized If class_tracker_id is not None, try to lookup an existing class definition matching that id. If none is found, track a newly reconstructed class definition under that id so that other instances stemming from the same class id will also reuse this class definition. The "extra" variable is meant to be a dict (or None) that can be used for forward compatibility shall the need arise. """ skeleton_class = types.new_class( name, bases, {'metaclass': type_constructor}, lambda ns: ns.update(type_kwargs) ) return _lookup_class_or_track(class_tracker_id, skeleton_class)
Example #10
Source Project: Project-New-Reign---Nemesis-Main Author: ShikyoKira File: test_types.py License: GNU General Public License v3.0 | 6 votes |
def test_prepare_class(self): # Basic test of metaclass derivation expected_ns = {} class A(type): def __new__(*args, **kwargs): return type.__new__(*args, **kwargs) def __prepare__(*args): return expected_ns B = types.new_class("B", (object,)) C = types.new_class("C", (object,), {"metaclass": A}) # The most derived metaclass of D is A rather than type. meta, ns, kwds = types.prepare_class("D", (B, C), {"metaclass": type}) self.assertIs(meta, A) self.assertIs(ns, expected_ns) self.assertEqual(len(kwds), 0)
Example #11
Source Project: Project-New-Reign---Nemesis-Main Author: ShikyoKira File: test_types.py License: GNU General Public License v3.0 | 6 votes |
def test_metaclass_override_function(self): # Special case: the given metaclass isn't a class, # so there is no metaclass calculation. class A(metaclass=self.Meta): pass marker = object() def func(*args, **kwargs): return marker X = types.new_class("X", (), {"metaclass": func}) Y = types.new_class("Y", (object,), {"metaclass": func}) Z = types.new_class("Z", (A,), {"metaclass": func}) self.assertIs(marker, X) self.assertIs(marker, Y) self.assertIs(marker, Z)
Example #12
Source Project: Project-New-Reign---Nemesis-Main Author: ShikyoKira File: util.py License: GNU General Public License v3.0 | 6 votes |
def specialize_class(cls, kind, base=None, **kwargs): # XXX Support passing in submodule names--load (and cache) them? # That would clean up the test modules a bit more. if base is None: base = unittest.TestCase elif not isinstance(base, type): base = base[kind] name = '{}_{}'.format(kind, cls.__name__) bases = (cls, base) specialized = types.new_class(name, bases) specialized.__module__ = cls.__module__ specialized._NAME = cls.__name__ specialized._KIND = kind for attr, values in kwargs.items(): value = values[kind] setattr(specialized, attr, value) return specialized
Example #13
Source Project: groupsoftmax-simpledet Author: chengzhengxin File: patch_config.py License: Apache License 2.0 | 6 votes |
def patch_config_as_nothrow(instance): if "NoThrow" in [instance.__name__, instance.__class__.__name__]: return instance if type(instance) == type: instance = types.new_class(instance.__name__ + "NoThrow", (instance, ), dict(metaclass=NoThrowMeta)) for (k, v) in inspect.getmembers(instance): if not k.startswith("__") and type(v) == type: type.__setattr__(instance, k, patch_config_as_nothrow(v)) else: for (k, v) in inspect.getmembers(instance.__class__): if not k.startswith("__") and type(v) == type: type.__setattr__(instance.__class__, k, patch_config_as_nothrow(v)) instance.__class__ = type(instance.__class__.__name__ + "NoThrow", (instance.__class__, NoThrowBase), {}) return instance
Example #14
Source Project: android_universal Author: bkerler File: test_types.py License: MIT License | 6 votes |
def test_prepare_class(self): # Basic test of metaclass derivation expected_ns = {} class A(type): def __new__(*args, **kwargs): return type.__new__(*args, **kwargs) def __prepare__(*args): return expected_ns B = types.new_class("B", (object,)) C = types.new_class("C", (object,), {"metaclass": A}) # The most derived metaclass of D is A rather than type. meta, ns, kwds = types.prepare_class("D", (B, C), {"metaclass": type}) self.assertIs(meta, A) self.assertIs(ns, expected_ns) self.assertEqual(len(kwds), 0)
Example #15
Source Project: android_universal Author: bkerler File: test_types.py License: MIT License | 6 votes |
def test_metaclass_override_function(self): # Special case: the given metaclass isn't a class, # so there is no metaclass calculation. class A(metaclass=self.Meta): pass marker = object() def func(*args, **kwargs): return marker X = types.new_class("X", (), {"metaclass": func}) Y = types.new_class("Y", (object,), {"metaclass": func}) Z = types.new_class("Z", (A,), {"metaclass": func}) self.assertIs(marker, X) self.assertIs(marker, Y) self.assertIs(marker, Z)
Example #16
Source Project: TestSlide Author: facebookincubator File: __init__.py License: MIT License | 5 votes |
def add_test_case(self, test_case, attr_name): """ Add around hooks to context from given unittest.TestCase class. Only hooks such as setUp or tearDown will be called, no tests will be included. """ def wrap_test_case(self, example): def test_test_slide(_): example() def exec_body(ns): ns.update({"test_test_slide": test_test_slide}) # Build a child class of given TestCase, with a defined test that # will run TestSlide example. test_slide_test_case = types.new_class( "TestSlideTestCase", bases=(test_case,), exec_body=exec_body ) # This suite will only contain TestSlide's example test. test_suite = unittest.TestLoader().loadTestsFromName( "test_test_slide", test_slide_test_case ) setattr(self, attr_name, list(test_suite)[0]) result = _TestSlideTestResult() test_suite(result=result) if not result.wasSuccessful(): result.aggregated_exceptions.raise_correct_exception() self.around_functions.append(wrap_test_case)
Example #17
Source Project: edgedb Author: edgedb File: tokens.py License: Apache License 2.0 | 5 votes |
def _gen_keyword_tokens(): # Define keyword tokens mod = sys.modules[__name__] def clsexec(ns): ns['__module__'] = __name__ return ns for token, _ in keywords.edgeql_keywords.values(): clsname = 'T_{}'.format(token) clskwds = dict(metaclass=parsing.TokenMeta, token=token) cls = types.new_class(clsname, (Token,), clskwds, clsexec) setattr(mod, clsname, cls)
Example #18
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_basics(self): C = types.new_class("C") self.assertEqual(C.__name__, "C") self.assertEqual(C.__bases__, (object,))
Example #19
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_subclass(self): C = types.new_class("C", (int,)) self.assertTrue(issubclass(C, int))
Example #20
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_meta(self): Meta = self.Meta settings = {"metaclass": Meta, "z": 2} # We do this twice to make sure the passed in dict isn't mutated for i in range(2): C = types.new_class("C" + str(i), (), settings) self.assertIsInstance(C, Meta) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2)
Example #21
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_exec_body(self): Meta = self.Meta def func(ns): ns["x"] = 0 C = types.new_class("C", (), {"metaclass": Meta, "z": 2}, func) self.assertIsInstance(C, Meta) self.assertEqual(C.x, 0) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2)
Example #22
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_metaclass_keywords(self): #Test that keywords are passed to the metaclass: def meta_func(name, bases, ns, **kw): return name, bases, ns, kw res = types.new_class("X", (int, object), dict(metaclass=meta_func, x=0)) self.assertEqual(res, ("X", (int, object), {}, {"x": 0}))
Example #23
Source Project: Fluid-Designer Author: Microvellum File: test_types.py License: GNU General Public License v3.0 | 5 votes |
def test_new_class_meta_with_base(self): Meta = self.Meta def func(ns): ns["x"] = 0 C = types.new_class(name="C", bases=(int,), kwds=dict(metaclass=Meta, z=2), exec_body=func) self.assertTrue(issubclass(C, int)) self.assertIsInstance(C, Meta) self.assertEqual(C.x, 0) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2) # Many of the following tests are derived from test_descr.py
Example #24
Source Project: dingtalk-python Author: blackmatrix7 File: exceptions.py License: Apache License 2.0 | 5 votes |
def __get__(self, instance, owner): supers = (DingTalkException, self.err_type, BaseException) \ if self.err_type and self.err_type is not BaseException else (DingTalkException, BaseException) api_ex_cls = types.new_class('DingTalkException', supers, {}, lambda ns: ns) api_ex = api_ex_cls(err_msg=self.err_msg, err_code=self.err_code, http_code=self.http_code) return api_ex
Example #25
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_basics(self): C = types.new_class("C") self.assertEqual(C.__name__, "C") self.assertEqual(C.__bases__, (object,))
Example #26
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_subclass(self): C = types.new_class("C", (int,)) self.assertTrue(issubclass(C, int))
Example #27
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_meta(self): Meta = self.Meta settings = {"metaclass": Meta, "z": 2} # We do this twice to make sure the passed in dict isn't mutated for i in range(2): C = types.new_class("C" + str(i), (), settings) self.assertIsInstance(C, Meta) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2)
Example #28
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_exec_body(self): Meta = self.Meta def func(ns): ns["x"] = 0 C = types.new_class("C", (), {"metaclass": Meta, "z": 2}, func) self.assertIsInstance(C, Meta) self.assertEqual(C.x, 0) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2)
Example #29
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_metaclass_keywords(self): #Test that keywords are passed to the metaclass: def meta_func(name, bases, ns, **kw): return name, bases, ns, kw res = types.new_class("X", (int, object), dict(metaclass=meta_func, x=0)) self.assertEqual(res, ("X", (int, object), {}, {"x": 0}))
Example #30
Source Project: ironpython3 Author: IronLanguages File: test_types.py License: Apache License 2.0 | 5 votes |
def test_new_class_meta_with_base(self): Meta = self.Meta def func(ns): ns["x"] = 0 C = types.new_class(name="C", bases=(int,), kwds=dict(metaclass=Meta, z=2), exec_body=func) self.assertTrue(issubclass(C, int)) self.assertIsInstance(C, Meta) self.assertEqual(C.x, 0) self.assertEqual(C.y, 1) self.assertEqual(C.z, 2) # Many of the following tests are derived from test_descr.py