Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/factory/helpers.py: 40%

1# Copyright: See the LICENSE file. 

2 

3 

4"""Simple wrappers around Factory class definition.""" 

5 

6import contextlib 

7import logging 

8 

9from . import base, declarations 

10 

11 

12@contextlib.contextmanager 

13def debug(logger='factory', stream=None): 

14 logger_obj = logging.getLogger(logger) 

15 old_level = logger_obj.level 

16 

17 handler = logging.StreamHandler(stream) 

18 handler.setLevel(logging.DEBUG) 

19 logger_obj.addHandler(handler) 

20 logger_obj.setLevel(logging.DEBUG) 

21 

22 try: 

23 yield 

24 finally: 

25 logger_obj.setLevel(old_level) 

26 logger_obj.removeHandler(handler) 

27 

28 

29def make_factory(klass, **kwargs): 

30 """Create a new, simple factory for the given class.""" 

31 factory_name = '%sFactory' % klass.__name__ 

32 

33 class Meta: 

34 model = klass 

35 

36 kwargs['Meta'] = Meta 

37 base_class = kwargs.pop('FACTORY_CLASS', base.Factory) 

38 

39 factory_class = type(base.Factory).__new__(type(base.Factory), factory_name, (base_class,), kwargs) 

40 factory_class.__name__ = '%sFactory' % klass.__name__ 

41 factory_class.__doc__ = 'Auto-generated factory for class %s' % klass 

42 return factory_class 

43 

44 

45def build(klass, **kwargs): 

46 """Create a factory for the given class, and build an instance.""" 

47 return make_factory(klass, **kwargs).build() 

48 

49 

50def build_batch(klass, size, **kwargs): 

51 """Create a factory for the given class, and build a batch of instances.""" 

52 return make_factory(klass, **kwargs).build_batch(size) 

53 

54 

55def create(klass, **kwargs): 

56 """Create a factory for the given class, and create an instance.""" 

57 return make_factory(klass, **kwargs).create() 

58 

59 

60def create_batch(klass, size, **kwargs): 

61 """Create a factory for the given class, and create a batch of instances.""" 

62 return make_factory(klass, **kwargs).create_batch(size) 

63 

64 

65def stub(klass, **kwargs): 

66 """Create a factory for the given class, and stub an instance.""" 

67 return make_factory(klass, **kwargs).stub() 

68 

69 

70def stub_batch(klass, size, **kwargs): 

71 """Create a factory for the given class, and stub a batch of instances.""" 

72 return make_factory(klass, **kwargs).stub_batch(size) 

73 

74 

75def generate(klass, strategy, **kwargs): 

76 """Create a factory for the given class, and generate an instance.""" 

77 return make_factory(klass, **kwargs).generate(strategy) 

78 

79 

80def generate_batch(klass, strategy, size, **kwargs): 

81 """Create a factory for the given class, and generate instances.""" 

82 return make_factory(klass, **kwargs).generate_batch(strategy, size) 

83 

84 

85def simple_generate(klass, create, **kwargs): 

86 """Create a factory for the given class, and simple_generate an instance.""" 

87 return make_factory(klass, **kwargs).simple_generate(create) 

88 

89 

90def simple_generate_batch(klass, create, size, **kwargs): 

91 """Create a factory for the given class, and simple_generate instances.""" 

92 return make_factory(klass, **kwargs).simple_generate_batch(create, size) 

93 

94 

95def lazy_attribute(func): 

96 return declarations.LazyAttribute(func) 

97 

98 

99def iterator(func): 

100 """Turn a generator function into an iterator attribute.""" 

101 return declarations.Iterator(func()) 

102 

103 

104def sequence(func): 

105 return declarations.Sequence(func) 

106 

107 

108def lazy_attribute_sequence(func): 

109 return declarations.LazyAttributeSequence(func) 

110 

111 

112def container_attribute(func): 

113 return declarations.ContainerAttribute(func, strict=False) 

114 

115 

116def post_generation(fun): 

117 return declarations.PostGeneration(fun)