Type info updated

docs/devel/example_closure.py

@@ -1,21 +1,23 @@
 # Python closure example
 
-def OuterCount(start):
-     counter = [start] # counter is 1-element array
-     print "passei por fora"
-     def InnerCount():
+from typing import List, Callable
+
+def OuterCount(start: int) -> Callable[[], int]:
+     counter: List[int] = [start] # counter is 1-element array
+     print("passei por fora")
+     def InnerCount() -> int:
          counter[0] = counter[0] + 1
-         print "passei por dentro"
+         print("passei por dentro")
          return counter[0]
      return InnerCount
 
-print "Init counter at 5"
-count = OuterCount(5)
-print "\nRun counter 3 times"
-print count()
-print count()
-print count()
+print("Init counter at 5")
+count: Callable[[], int] = OuterCount(5)
+print("\nRun counter 3 times")
+print(count())
+print(count())
+print(count())
 
-print "**********"
+print("**********")
 count = OuterCount(0)
-print count()
+print(count())

docs/devel/example_pubsub.py

@@ -4,14 +4,15 @@
 # http://wiki.wxpython.org/ModelViewController
 # http://wiki.wxpython.org/PubSub
 from invesalius.pubsub import pub as Publisher
+from typing import Dict, Any
 
 # The maintainer of Pubsub module is Oliver Schoenborn.
 # Since the end of 2006 Pubsub is now maintained separately on SourceForge at:
 # http://pubsub.sourceforge.net/
 
 
 class Student:
-    def __init__(self, name):
+    def __init__(self, name: str):
         self.name = name
         self.mood = ":|"
         self.__bind_events()
@@ -20,39 +21,39 @@ def __bind_events(self):
         Publisher.subscribe(self.ReceiveProject, "Set Student Project")
         Publisher.subscribe(self.ReceiveGrade, "Set Student Grade")
 
-    def ReceiveProject(self, pubsub_evt):
-        projects_dict = pubsub_evt.data
+    def ReceiveProject(self, pubsub_evt: Any):
+        projects_dict: Dict[str, str] = pubsub_evt.data
         self.project = projects_dict[self.name]
-        print "%s: I've received the project %s" % (self.name, self.project)
+        print(f"{self.name}: I've received the project {self.project}")
 
-    def ReceiveGrade(self, pubsub_evt):
-        grades_dict = pubsub_evt.data
+    def ReceiveGrade(self, pubsub_evt: Any):
+        grades_dict: Dict[str, float] = pubsub_evt.data
         self.grade = grades_dict[self.name]
         if self.grade > 6:
             self.mood = ":)"
         else:
             self.mood = ":("
-        print "%s: I've received the grade %d %s" % (self.name, self.grade, self.mood)
+        print(f"{self.name}: I've received the grade {self.grade} {self.mood}")
 
 
 class Teacher:
-    def __init__(self, name, course):
+    def __init__(self, name: str, course: Any):
         self.name = name
         self.course = course
 
     def SendMessage(self):
-        print "%s: Telling students the projects" % (self.name)
+        print(f"{self.name}: Telling students the projects")
         Publisher.sendMessage("Set Student Project", self.course.projects_dict)
 
-        print "\n%s: Telling students the grades" % (self.name)
+        print(f"\n{self.name}: Telling students the grades")
         Publisher.sendMessage("Set Student Grade", self.course.grades_dict)
 
 
 class Course:
-    def __init__(self, subject):
+    def __init__(self, subject: str):
         self.subject = subject
-        self.grades_dict = {}
-        self.projects_dict = {}
+        self.grades_dict: Dict[str, float] = {}
+        self.projects_dict: Dict[str, str] = {}
 
 
 # Create students:

docs/devel/example_singleton.py

@@ -7,48 +7,48 @@
 class Singleton(type):
     # This is a Gary Robinson implementation:
     # http://www.garyrobinson.net/2004/03/python_singleto.html
-    def __init__(cls,name,bases,dic):
-        super(Singleton,cls).__init__(name,bases,dic)
-        cls.instance=None
-        
-    def __call__(cls,*args,**kw):
+    def __init__(cls, name: str, bases: tuple, dic: dict) -> None:
+        super().__init__(name, bases, dic)
+        cls.instance = None
+
+    def __call__(cls, *args: tuple, **kw: dict) -> object:
         if cls.instance is None:
-            cls.instance=super(Singleton,cls).__call__(*args,**kw)
+            cls.instance = super().__call__(*args, **kw)
         return cls.instance
 
 class Bone(object):
     # Only one project will be initialized per time. Therefore, we use
     # Singleton design pattern for implementing it
     __metaclass__= Singleton
 
-    def __init__(self):
-        self.size = 100
-
-    def RemovePart(self, part_size):
-        self.size -= part_size # self.size = self.size - part_size
-
-class Dog():
-    def __init__(self, name):
-        self.name = name
-        self.bone = Bone()
-
-    def EatBonePart(self, part_size):
-        self.bone.RemovePart(part_size) 
-
-print "Initial state:"
-d1 = Dog("Nina")
-d2 = Dog("Tang")
-print "Bone size of %s: %d"%(d1.name, d1.bone.size)
-print "Bone size of %s: %d\n"%(d2.name, d2.bone.size)
-
-print "Only Nina eats:"
-d1.EatBonePart(5)
-print "Bone size of %s: %d"%(d1.name, d1.bone.size)
-print "Bone size of %s: %d\n"%(d2.name, d2.bone.size)
+    def __init__(self) -> None:
+        self.size: int = 100
 
-print "Tang eats after Nina:"
-d2.EatBonePart(20)
-print "Bone size of %s: %d"%(d1.name, d1.bone.size)
-print "Bone size of %s: %d"%(d2.name, d2.bone.size)
+    def RemovePart(self, part_size: int) -> None:
+        self.size -= part_size
+
+
+class Dog:
+    def __init__(self, name: str) -> None:
+        self.name: str = name
+        self.bone: Bone = Bone()
 
+    def EatBonePart(self, part_size: int) -> None:
+        self.bone.RemovePart(part_size)
 
+
+print("Initial state:")
+d1: Dog = Dog("Nina")
+d2: Dog = Dog("Tang")
+print(f"Bone size of {d1.name}: {d1.bone.size}")
+print(f"Bone size of {d2.name}: {d2.bone.size}\n")
+
+print("Only Nina eats:")
+d1.EatBonePart(5)
+print(f"Bone size of {d1.name}: {d1.bone.size}")
+print(f"Bone size of {d2.name}: {d2.bone.size}\n")
+
+print("Tang eats after Nina:")
+d2.EatBonePart(20)
+print(f"Bone size of {d1.name}: {d1.bone.size}")
+print(f"Bone size of {d2.name}: {d2.bone.size}")

docs/devel/example_singleton_pubsub.py

@@ -6,13 +6,13 @@ class Singleton(type):
     # This is a Gary Robinson implementation:
     # http://www.garyrobinson.net/2004/03/python_singleto.html
 
-    def __init__(cls,name,bases,dic):
-        super(Singleton,cls).__init__(name,bases,dic)
-        cls.instance=None
-        
-    def __call__(cls,*args,**kw):
+    def __init__(cls, name: str, bases: tuple, dic: dict):
+        super(Singleton, cls).__init__(name, bases, dic)
+        cls.instance = None
+
+    def __call__(cls, *args, **kw):
         if cls.instance is None:
-            cls.instance=super(Singleton,cls).__call__(*args,**kw)
+            cls.instance = super(Singleton, cls).__call__(*args, **kw)
         return cls.instance
 
 class Pizza(object):
@@ -21,42 +21,41 @@ class Pizza(object):
     __metaclass__= Singleton
 
     def __init__(self):
-        self.npieces = 8
+        self.npieces: int = 8
         self.__bind_events()
 
     def __bind_events(self):
-        ps.Publisher().subscribe(self.RemovePiece,
-                                 'Eat piece of pizza')
+        Publisher.subscribe(self.RemovePiece, 'Eat piece of pizza')
 
-    def RemovePiece(self, pubsub_evt):
-        person = pubsub_evt.data
+    def RemovePiece(self, pubsub_evt: Publisher):
+        person: Person = pubsub_evt.data
         if self.npieces:
             self.npieces -= 1
-            print "%s ate pizza!"%(person.name)
+            print(f"{person.name} ate pizza!")
         else:
-            print "%s is hungry!"%(person.name)
+            print(f"{person.name} is hungry!")
+
 
 class Person():
-    def __init__(self, name):
-        self.name = name
-        self.pizza = Pizza()
+    def __init__(self, name: str):
+        self.name: str = name
+        self.pizza: Pizza = Pizza()
 
     def EatPieceOfPizza(self):
-        ps.Publisher.sendMessage('Eat piece of pizza',(self))
-        
+        Publisher.sendMessage('Eat piece of pizza', (self,))
+
 
-print "Initial state:"
-p1 = Person("Paulo ") 
-p2 = Person("Thiago")
-p3 = Person("Andre ")
-people = [p1, p2, p3]
+print("Initial state:")
+p1: Person = Person("Paulo ")
+p2: Person = Person("Thiago")
+p3: Person = Person("Andre ")
+people: list = [p1, p2, p3]
 
-print "Everyone eats 2 pieces:"
+print("Everyone eats 2 pieces:")
 for i in range(2):
     for person in people:
         person.EatPieceOfPizza()
 
-print "Everyone tries to eat another piece:"
+print("Everyone tries to eat another piece:")
 for person in people:
-    person.EatPieceOfPizza()
-
+    person.EatPieceOfPizza()