pyproteum 0.1__py3-none-any.whl

pyproteum/__init__.py

@@ -0,0 +1 @@
+

pyproteum/__main__.py

@@ -0,0 +1,22 @@
+from pyproteum import testnew, tcase, mutagen, exemuta, mutaview
+import sys
+
+if __name__ == '__main__':
+	del sys.argv[0]
+	if sys.argv ==[]:
+		print('You should use one of the pyproteum commands.')
+	else:	
+		match sys.argv[0]: 
+			case 'testnew':
+				testnew.main()
+			case 'tcase':
+				tcase.main()
+			case 'mutagen':
+				mutagen.main()
+			case 'exemuta':
+				exemuta.main()
+			case 'mutaview':
+				mutaview.main()
+			case _:
+				print(f'Not found statement {sys.argv[0]}')
+

pyproteum/exemuta.py

@@ -0,0 +1,316 @@
+import sys, csv
+import os,io
+from pyproteum.models.models import *
+import unittest
+import pickle
+import types
+from pyproteum.moperators.myoperator import *
+from pyproteum.tcase import change_dir_connect
+from pyproteum.tcase import load_module, get_all_test_names
+import timeout_decorator
+import inspect
+
+
+class RegistrandoResultado(unittest.TextTestResult):
+	def __init__(self, stream, descriptions, verbosity, number, research):
+		super().__init__(stream, descriptions, verbosity)
+		self.my_successes = []  # armazena os testes que passaram
+		self.timeouts = []
+		self.all = []		# todos os testes executados
+		self.all_order = {}
+		self.order = number
+		self.count = 0
+		self.research = research
+
+	def startTest(self, test):
+		self.all.append(test)
+		self.count += 1
+		self.all_order[test.id()] = '{}:{}'.format(self.order, self.count)
+		super().startTest(test)
+
+	def addSuccess(self, test):
+		self.my_successes.append(test)
+		super().addSuccess(test)
+
+	def stopTest(self, test):
+		super().stopTest(test)
+	
+	def addFailure(self, test, err):
+		etype, evalue, tb = err
+		# Marcação explícita de TIMEOUT
+		if getattr(etype, "__name__", "") in ("TimeoutError", "TimeoutError_", "TimeoutException"):
+			# opcional: anotar em um campo extra
+			self.timeouts.append(test)				
+		super().addFailure(test, err)
+		if not self.research:
+			self.stop()
+
+	def addError(self, test, err):
+		etype, evalue, tb = err
+		# Marcação explícita de TIMEOUT
+		if getattr(etype, "__name__", "") in ("TimeoutError", "TimeoutError_", "TimeoutException"):
+			# opcional: anotar em um campo extra
+			self.timeouts.append(test)		
+		super().addError(test, err)
+		if not self.research:
+			self.stop()
+
+
+class RegistrandoRunner(unittest.TextTestRunner):
+
+	def __init__(self, *args, number=0, research=False, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.number = number
+		self.research = research
+
+	def _makeResult(self):
+		return RegistrandoResultado(self.stream, self.descriptions, self.verbosity, self.number,self.research)
+
+
+
+
+def create_module_from_ast(nome_modulo, arvore_ast):
+	modulo = types.ModuleType(nome_modulo)
+	code = compile(arvore_ast, filename="<ast>", mode="exec")
+	exec(code, modulo.__dict__)
+	sys.modules[nome_modulo] = modulo
+	return modulo
+
+	
+
+
+def __exec():
+	session_name = sys.argv[-1]
+	directory = None
+	i = 2
+	keep = False
+	while i < len(sys.argv[:-1]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--keep':
+				keep = True
+			case _:
+				usage()
+				return
+		i += 1
+	
+	change_dir_connect(directory, session_name)
+	session = Session.get(Session.id==1)
+	rse = session.type == 'research'
+
+	fields = get_all_test_names()
+	Execution = create_exec_db(fields)
+
+	cont_dead = 0
+	cont_live = 0
+	cont_equiv = 0
+
+	for muta in Mutant:
+		if muta.status == 'Equivalent':
+			cont_equiv += 1
+			continue
+
+		if keep and muta.status != 'live' and not rse:
+			cont_dead += 1
+			continue
+		print('Mutant {} -- {}'.format(muta.id, muta.operator))
+		tree = pickle.loads(muta.ast)
+		create_module_from_ast(os.path.splitext(os.path.basename(muta.source.filename))[0], tree)
+		reg_muta = Execution.create(mutant=muta)
+		#print(reg_muta)
+		dead = False
+		for testfile in TestCase:
+			try: 
+				module_test = load_module(testfile.filename)
+				aplicar_timeout_em_tests(module_test)
+				suite = unittest.TestLoader().loadTestsFromModule(module_test)
+				resultado = RegistrandoRunner(stream=io.StringIO(), research=rse,verbosity=0,number=testfile.id).run(suite)
+			except Exception as ex:
+				print(f'Error. Can not run test file {testfile}')
+				print(ex)
+				sys.exit()
+			
+			for test,_ in resultado.failures:
+				t = resultado.all_order[test.id()]
+				if test in resultado.timeouts:
+					s = 'timeout'
+				else:
+					s = 'fail'
+				print(f'{t} {s}.')
+				
+				setattr(reg_muta, test.id(), s)
+				reg_muta.save()				
+				dead = True
+				
+			for test in resultado.my_successes:
+				t = resultado.all_order[test.id()]
+				print(f'{t} passed.')
+				setattr(reg_muta, test.id(), 'live')
+				reg_muta.save()
+			for test,_ in resultado.errors:
+				t = resultado.all_order[test.id()]
+				print(f'{t} error.')
+				setattr(reg_muta, test.id(), 'error')
+				reg_muta.save()
+				dead = True
+			if dead and not rse:
+				break
+
+				
+		if dead:
+			muta.status = 'Dead'
+			print('Dead')
+			cont_dead += 1
+			muta.save()
+		else:
+			cont_live += 1
+	
+	print(f'Alive: {cont_live}')
+	print(f'Dead: {cont_dead}')
+	print(f'Equivalent: {cont_equiv}')
+	print('Mutation score: {:.2f}'.format(cont_dead/(cont_live+cont_dead)))
+
+	
+def create_exec_db(fields):
+	model_dict = { 'mutant' : ForeignKeyField(Mutant, backref='executed')}
+	fields = sorted(fields)
+	for r in fields:
+		model_dict[r] = TextField(default='No Exec')	
+	Execution = criar_modelo('Execution', model_dict)
+	db.drop_tables([Execution])
+	db.create_tables([Execution])
+	return Execution
+
+TIMEOUT_SEGUNDOS = 2
+
+def aplicar_timeout_em_tests(modulo):
+	for nome, obj in inspect.getmembers(modulo):
+		if inspect.isclass(obj) and issubclass(obj, unittest.TestCase):
+			for metodo_nome, metodo in inspect.getmembers(obj, inspect.isfunction):
+				if metodo_nome.startswith("test_"):
+					setattr(obj, metodo_nome, timeout_decorator.timeout(TIMEOUT_SEGUNDOS, use_signals=False)(metodo))
+	
+def __csv():
+	session_name = sys.argv.pop()
+	directory = None
+	outname = None
+	i = 2
+	while i < len(sys.argv[:-1]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--O':
+				i += 1
+				outname = sys.argv[i]
+			case _:
+				usage()
+				return
+		i += 1
+
+	change_dir_connect(directory, session_name)
+
+	if outname is None:
+		outname = session_name+'.csv'
+
+	try:
+		Execution = get_table_model('Execution')
+	except Exception as ex:
+		print('Previous execution not found. Try "exemuta.py --exec" before exporting')
+		print(ex)
+		sys.exit()
+
+	try:
+		with open(outname, 'w') as out:
+			writer = csv.writer(out)
+			campos = [field.name for field in Execution._meta.sorted_fields]
+			campos.remove('id')
+			writer.writerow(campos)
+			for registro in Execution.select():
+				writer.writerow([getattr(registro, campo) for campo in campos])
+		print(f'{outname} successfully generated')
+	except Exception as ex:
+		print(f'Could not generate {outname}')
+		print(ex)
+		sys.exit()
+
+
+def __equiv():
+	session_name = sys.argv[-1]
+	directory = None
+	muta_number = None
+	i = 2
+	while i < len(sys.argv[:-2]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--x':
+				i += 1
+				list_number = sys.argv[i]
+			case _:
+				usage()
+				return
+		i += 1
+
+	if not list_number:
+		print('Mutant number not provided')
+		sys.exit()
+
+	try: 
+		change_dir_connect(directory, session_name)
+	except Exception as ex:
+		print(f'Can not access test session')
+		print(ex)
+		sys.exit()	
+
+	for muta_number in list_number.split():
+		try:
+			muta_number = int(muta_number)
+			reg_muta = Mutant.get(Mutant.id==muta_number)
+			print('Mutant: ', reg_muta.id)
+			if not reg_muta.status in ['live','equiv']:
+				print(f'Warning: mutant {reg_muta.id} is not alive. It is {reg_muta.status}')
+			reg_muta.status = 'equiv'
+			reg_muta.save()
+		except Exception as ex:
+			print(f'Can not access mutant number {muta_number}')
+			print(ex)
+			#sys.exit()
+
+def main():
+	n = len(sys.argv)-2
+	if n < 1:
+		usage()
+	
+	if sys.argv[1] == '--exec':
+		__exec()
+		return
+	elif sys.argv[1] == '--csv':
+		__csv()
+		return
+	elif sys.argv[1] == '--equiv':
+		__equiv()
+		return
+	else:
+		usage()
+
+
+def usage():
+	print('Usage:')
+	print('exemuta --exec [--keep] [--D <directory> ]  <session name>')
+	print('\tExecute the mutants with the test cases in the session')
+	print('\t--keep: execute only the live mutants')
+	print('exemuta --csv [--D <directory> ]  <session name>')
+	print('\tExports the last execution to a csv file')
+	print('exemuta --equiv --x <list of numbers> [--D <directory> ]  <session name>')
+	print('\tMarks mutants as equivalents') 
+	sys.exit()
+
+if __name__ == '__main__' :
+	main()

pyproteum/models/models.py

@@ -0,0 +1,89 @@
+from peewee import *
+from datetime import datetime
+
+db = Proxy()
+
+class BaseModel(Model):
+	class Meta:
+		database = db
+
+class Session(BaseModel):
+	filename = CharField(unique=True)
+	type = TextField()
+	#ast = BlobField()
+	criado = DateTimeField(default=datetime.now)
+
+class TestCase(BaseModel):
+	filename = CharField(unique=True)
+	criado = DateTimeField(default=datetime.now)
+
+
+class Mutant(BaseModel):
+	source = ForeignKeyField(Session, backref='mutants')
+	operator = TextField()
+	function = TextField()
+	func_lineno = IntegerField()
+	func_end_lineno = IntegerField()
+	lineno = IntegerField()
+	col_offset = IntegerField()
+	end_lineno = IntegerField()
+	end_col_offset = IntegerField()
+	seq_number = IntegerField()
+	ast = BlobField()
+	status = TextField(default='live')
+	criado = DateTimeField(default=datetime.now)
+
+	class Meta:
+		indexes = (
+			(('source', 'lineno', 'col_offset','operator','seq_number'), True),  # combinação única
+		)
+
+	def __str__(self):
+		s = f'Source: {self.source.filename}\n'
+		s += f'Operator: {self.operator}\n'
+		s += f'Func Lineno: {self.func_lineno}\n'
+		s += f'Func End Lineno: {self.func_end_lineno}\n'
+		s += f'Lineno: {self.lineno}\n'
+		s += f'End Lineno: {self.end_lineno}\n'
+		return s
+
+def criar_modelo(nome_modelo, campos):
+	class Meta:
+		database = db
+
+	atributos = dict(campos)
+	atributos['Meta'] = Meta
+	return type(nome_modelo, (Model,), atributos)
+
+#uso: 
+# campos = {
+#	 'titulo': CharField(),
+#	 'ano': IntegerField(),
+#	 'autor': CharField(),
+# }
+
+# Livro = criar_modelo('Livro', campos, db)
+# db.create_tables([Livro])
+# Livro.create(titulo='Dom Casmurro', ano=1899, autor='Machado de Assis')
+#db.drop_tables([Model1, Model2])
+
+def get_table_model(table_name):
+	colunas = db.get_columns(table_name)
+	atributos = {
+		'_meta': type('Meta', (), {'database': db, 'table_name': table_name})
+	}
+	for col in colunas:
+		atributos[col.name] = Field()
+	return type(table_name, (BaseModel,), atributos)
+
+# Livro = get_table_model('Livro')
+
+def criar_modelo_dinamico(nome_tabela):
+	colunas = db.get_columns(nome_tabela)
+	atributos = {
+		'_meta': type('Meta', (), {'database': db, 'table_name': nome_tabela})
+	}
+	for col in colunas:
+		# Usa Field genérico para não errar o tipo
+		atributos[col.name] = Field()
+	return type(nome_tabela, (BaseModel,), atributos)

pyproteum/moperators/cccr.py

@@ -0,0 +1,34 @@
+import ast
+from pyproteum.moperators.myoperator import *
+
+
+class Cccr(MyOperator):
+	
+	def __init__(self, original):
+		super().__init__(original)
+		self.seq = 1
+		self.const_set = set()
+
+	def visit_FunctionDef(self, node):
+		old_set = set(self.const_set)
+		super().visit_FunctionDef(node)
+		self.const_set = old_set
+		return node
+
+	def visit_Constant(self, node):
+		old_value = node.value
+		self.const_set.add(old_value)
+
+		for new_value in self.const_set:
+			if new_value == old_value:
+				continue
+			if type(new_value) != type(old_value):
+				continue
+			node.value = new_value
+			self.salva_muta(node, self.function, self.func_lineno, self.func_end_lineno,seq=self.seq)
+			self.seq += 1
+			
+		node.value = old_value
+		self.generic_visit(node)
+		return node
+		

pyproteum/moperators/ccsr.py

@@ -0,0 +1,56 @@
+import ast
+from pyproteum.moperators.myoperator import *
+import copy
+
+
+class Ccsr(MyOperator):
+	
+	def __init__(self, original):
+		super().__init__(original)
+		self.seq = 1
+		self.scalar_set = set()
+		ParentSetter().visit(self.original)
+
+
+
+	def visit_FunctionDef(self, node):
+		old_set = set(self.scalar_set)
+		super().visit_FunctionDef(node)
+		self.scalar_set = old_set
+		return node
+
+	def visit_Name(self, node):
+		if isinstance(node.ctx, ast.Store) :
+			self.scalar_set.add(ast.Name(id=copy.deepcopy(node.id), ctx=ast.Load()))
+		self.generic_visit(node)
+		return node
+
+	def visit_arg(self, node):
+		if node.arg != 'self':
+			self.scalar_set.add(ast.Name(id=copy.deepcopy(node.arg), ctx=ast.Load()))
+		self.generic_visit(node)
+		return node
+
+	def visit_Constant(self, node):
+		p, fld, idx = node.parent, node.parent_field, node.parent_index
+
+
+		for new_value in self.scalar_set:
+			ast.copy_location(new_value, node)
+			if idx is not None:
+				lst = getattr(p, fld)
+				lst[idx] = new_value
+			else:
+				setattr(p,fld, new_value)
+			self.salva_muta(p, self.function, self.func_lineno, self.func_end_lineno,seq=self.seq)
+			self.seq += 1
+
+		if idx is not None: 
+			lst = getattr(p, fld)
+			lst[idx] = node
+		else:
+			setattr(p,fld, node)		
+
+		self.generic_visit(node)
+		return node
+		

pyproteum/moperators/crcr.py

@@ -0,0 +1,33 @@
+
+import ast
+from pyproteum.moperators.myoperator import *
+
+
+class Crcr(MyOperator):
+	
+	def __init__(self, original):
+		super().__init__(original)
+		self.seq = 1
+	
+	def visit_Constant(self, node):
+		old_value = node.value
+
+		for new_value in self.get_required(node.value):
+			if new_value == old_value:
+				continue
+			node.value = new_value
+			self.salva_muta(node, self.function, self.func_lineno, self.func_end_lineno,seq=self.seq)
+			self.seq += 1
+		node.value = old_value
+		return self.generic_visit(node)
+
+	def get_required(self, value):
+		if isinstance(value, int):
+			return [-1, 0, 1]
+		if isinstance(value, float):
+			return [-1.0, 0.0, 1.0, 1E-13, 1E+13]
+		if isinstance(value, str):
+			return ['',' ']		
+		if isinstance(value, bytes):
+			return [b'',b' ']		
+		return []

pyproteum/moperators/myoperator.py

@@ -0,0 +1,155 @@
+import ast
+import copy
+from pyproteum.print_visit import PrintVisit
+
+
+
+class MyOperator(ast.NodeTransformer):
+	
+	def __init__(self, original):
+		self.original = copy.deepcopy(original)
+		self.mutants = []
+		self.function = ''
+		self.func_lineno = 0
+		self.func_end_lineno = 0		
+		self.docstrings = set()
+		self.pre_visit(self.original)
+
+	def pre_visit(self, tree):
+		for node in ast.walk(tree):
+			try:
+				if ast.get_docstring(node):
+					fn = node.body[0]
+					self.docstrings.add(id(fn))
+			except: 
+				continue
+
+	def salva_muta(self, node, func, ln, eln, seq=1):
+		cop = copy.deepcopy(self.original)
+		#self.ajustar_col_offsets(cop, node.lineno, node.col_offset, desloca)
+		ast.fix_missing_locations(cop)
+
+		if self.check_sintaxe(cop):
+			muta = MutantDict({'function': func,
+					'func_lineno': ln,
+					'func_end_lineno': eln,
+					'operator': str(self),
+					'lineno':node.lineno,
+					'col_offset':node.col_offset,
+					'end_lineno':node.end_lineno,
+					'end_col_offset':node.end_col_offset,
+					'seq_number' : seq,
+					'ast':cop
+					})
+			self.mutants.append(muta)
+		else:
+			print(f'Skiping mutant {str(self)}')
+			pass
+		
+
+
+	# def ajustar_col_offsets(self, node_raiz, linha_alvo, col_alvo, deslocamento):
+	# 	for no in ast.walk(node_raiz):
+	# 		if hasattr(no, 'lineno') and hasattr(no, 'col_offset'):
+	# 			if no.lineno == linha_alvo and no.col_offset > col_alvo:
+	# 				no.col_offset += deslocamento
+	# 				# print(no, linha_alvo, col_alvo, no.lineno, no.col_offset)
+
+		
+	def go_visit(self):
+		self.visit(self.original)
+
+	def visit_FunctionDef(self, node):
+		old_f = self.function
+		old_l = self.func_lineno
+		old_el = self.func_end_lineno
+		self.function = node.name
+		self.func_lineno = node.lineno
+		self.func_end_lineno = node.end_lineno
+		r = self.generic_visit(node)
+		self.function = old_f
+		self.func_end_lineno = old_el
+		self.func_lineno = old_l
+		return r
+
+	def visit_Expr(self, node):
+		if id(node) in self.docstrings:
+			return node		
+		return self.generic_visit(node)
+
+	def __str__(self):
+		s = str(type(self))
+		return s [-6:-2].lower()
+		
+
+	def check_sintaxe(self,tree):
+		unv = PrintVisit(tree)
+		try:
+			unv.go_visit()
+			ast.parse(str(unv))
+			return True
+		except Exception as ex:
+			print(unv)
+			print(ex)
+			return False
+
+	
+	def show_node(self, node):
+		print('\n', node)
+		if hasattr(node, 'lineno'):
+			print(f'lineno: {node.lineno}')			
+			print(f'end_lineno: {node.end_lineno}')
+			print(f'col_offset: {node.col_offset}')	
+			print(f'end_col_offset: {node.end_col_offset}')					
+
+class MutantDict(dict):
+
+
+	def __lt__(self, other):
+		if self['operator'] < other['operator']:
+			return True
+		if self['operator'] > other['operator']:
+			return False
+		if self['lineno'] < other['lineno']:
+			return True
+		if self['lineno'] > other['lineno']:
+			return False
+		if self['col_offset'] < other['col_offset']:
+			return True
+		if self['col_offset'] > other['col_offset']:
+			return False
+		if self['seq_number'] < other['seq_number']:
+			return True
+		if self['seq_number'] > other['seq_number']:
+			return False
+		return False
+
+
+# This class is used to set the parent of each node.
+# Not all operators use this
+# CCsr 
+class ParentSetter(ast.NodeVisitor):
+    def visit(self, node):
+        # garante que todo nó tenha attrs (pai/campo/índice podem já ter sido definidos)
+        if not hasattr(node, "parent"):
+            node.parent = None
+            node.parent_field = None
+            node.parent_index = None
+        super().visit(node)
+
+    def generic_visit(self, node):
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, ast.AST):
+                value.parent = node
+                value.parent_field = field
+                value.parent_index = None
+                self.visit(value)
+            elif isinstance(value, list):
+                for i, item in enumerate(value):
+                    if isinstance(item, ast.AST):
+                        item.parent = node
+                        item.parent_field = field
+                        item.parent_index = i
+                        self.visit(item)
+
+