View difference between Paste ID: yHBbhE3s and wT5KTwZe

-#! /bin/python
+
-# Ported my own code in a different language (HASKELL)
+
-# TO Python
+
-# and not having haskells pure functional methods
+
-# do hurt while porting to python :-/
+
 females = ["mother", "aunty", "daugther", "sister"]
 levels = ["grand", "great", "great ", "great"]
-# This code lacks utils, code that will be sent later on
+
-# Utils is easy peasy its just a shortest path finder
+
-# and then digester
+
 grandparents = ["grandpa", "grandma", "grandfather", "grandmother"]
 cousin = "cousin"
 
 
 # This comes from My utils
 # need to finish that
 # basically what it does is
 # look for the "lookup parameter"
 # and then convert into these direct relations as possible
 direct_relations = {
 	"brother": "- male",
 	"sister": "- female",
 	"daughter" : "> female",
 	"son": "> male",
 	"father": "< male",
 	"mother": "< female",
 }
 
 indirect_relations = {
 	"cousin": "-- male | female",
 	"uncle" : "-< male",
 	"aunty" : "-< female",
 	"nephew": "-> male",
 	"neice": "-> female"
 }
 
 class Person():
 	def __init__(self, gender):
 		self.gender = gender
 		self.parents = {
 								 "mother": None,
 								 "father": None
 				}; // Only two parents
 		self.kids = {
 			"sons": [],
 			"daughters": []
 		};
 		self.siblings = []
 		self.husband = None
 		self.wife = None
 
 	# deprecated
 	# Finds the spouse, helpful in finding stuff
 	def findSpouse(self):
 		the_chosen_one = None
 
 		if len(self.kids["daughters"]) > 0:
 			the_chosen_one = self.kids["daughters"][0]
 		if len(self.kids["sons"]) > 0:
 			the_chosen_one = self.kids["sons"][0]
 		if the_chosen_one is None:
 			return None
 
 		spouse = None
 
 		if( self.gender is "male"):
 			spouse = the_chosen_one.parents["mother"]
 		if( self.gender is "female"):
 			spouse = the_chosen_one.parents["father"]
 
 		return spouse
 
 	def addSpouse(self, spouse):
 		if relation in ["husband", "wife"]:
 			self[relation] = spouse
 			# Now the kids must be brothers and sisters :P
 			# and blah blah blah
 			# Okay this part of the code i am ashamed about completely
 			# unreadable
 			for x in range(0, len(self.kids["daughter"])):
 				for y in range(0, len(spouse.kids["daugthers"])):
 					spouse.kids["daughters"][y].addSibling( self.kids["daughter"][x], "sister")
 					self.addChild(spouse.kids["daughters"][y], "daughter")
 
 				for y in range(0, len(spouse.kids["sons"])):
 					spouse.kids["sons"][y].addSibling( self.kids["daughter"][x], "sister")
 					self.addChild(spouse.kids["sons"][y], "son")
 
 			for x in range(0, len(self.kids["sons"])):
 				for y in range(0, len(spouse.kids["daugthers"])):
 					spouse.kids["daughters"][y].addSibling( self.kids["sons"][x], "brother")
 				for y in range(0, len(spouse.kids["sons"])):
 					spouse.kids["sons"][y].addSibling( self.kids["sons"][x], "brother")
 
 	# Adds child
 	def addChild(self, child, relation):
 		if relation in ["son", "daughter"]:
 
 			# Add brothers
 			for i in range(0, len( self.kids["sons"] )):
 				self.kids["sons"][i].addSibling(child)
 
 			# Add sisters
 			for i in range(0, len( self.kids["sons"] )):
 				self.kids["sons"][i].addSibling(child)
 
 
 			self.kids[relation + "s"].push(child)
 
 			rel = "father"
 			if self.gender is "female":
 				rel = "mother"
 
 			child.addParent(self, rel)
 
 
 
 
 	def addGrandChild(self, child, relation):
 		# Yes we know its grand child ... remove it
 		relation = relation.replace("grand", "")
 
 		gender = "male",
 		rel = "son"
 
 		if "maternal" in relation:
 			gender = "female"
 			rel = "daughter"
 
 		parent =  Person(gender)
 		self.addChild(parent, rel)
 		parent.addChild(child, relation)
 
 	# Adds parent
 	def addParent(self, parent, relation):
 		if relation in ["father", "mother"]:
 			self.parents[relation] = parent
 			rel = "son"
 
 			if self.gender is "female":
 				rel = "daughter"
 			parent.addChild(self, rel)
 
 
 	# Adds sibling
 	def addSibling(self, sibling):
 		sibling.parent["mother"] = self.parent["mother"] = self.parent["mother"] or sibling.parent["mother"]
 		sibling.parent["father"] = self.parent["father"] = self.parent["father"] or sibling.parent["father"]
 		self.siblings.push( sibling )
 		sibling.siblings.push( self )
 
 	# Add Cousins. .. to achieve that add Parent and then add sibling to a parent
 	# Two virtual fathers are added here, this is ambigous
 	# Simple case not handling paternal and maternal cases
 	# Input : Maternal cousin brother
 	# Input : Cousin Sister
 	def addCousin(self, cousin, relation):
 		# Add an uncle
 		uncle =  Person("male")
 
 		# Find out if the uncle is maternal or paternal
 		# assume paternal if not present
 		if "maternal" in relation:
 			# Add a sibling to mom
 			# or Add a mom and then add this cousin
 			if self.parents["mother"] is None:
 				self.parents["mother"] =  Person("female")
 			self.parents["mother"].addSibling( uncle )
 		else:
 			if self.parents["father"] is None:
 				self.parents["father"] =  Person("male")
 			self.parents["father"].addSibling( uncle )
 
 		if "brother" in relation:
 			uncle.addChild( cousin, "son" )
 
 		elif "sister" in relation:
 			uncle.addChild( cousin, "daughter" )
 
 		else:
 			throw Error("Unknown relation")
 
 
 
 
 def feedData(sentence):
 	sentence = sentence.lower()
 	tokens = nltk.word_tokenize(sentence)
 	relation = ""
 	currentNode = None
 	meNode = None
 	tempNode = None
 
 	for x in range(0, len(tokens)):
 		relation = tokens[i]
 
 		if relation is "my":
 			meNode = tempNode =  Person("male")
 
 		if relation in siblings:
 			gen = "male"
 			if relation is "sister":
 				gen = "female"
 			tempNode =  Person(gen)
 			currentNode.addSibling(tempNode, relation)
 
 		if relation in children:
 			gen = "male"
 			if relation is "daughter":
 				gen = "female"
 			tempNode =  Person(gen)
 			currentNode.addSibling(tempNode, relation)
 
 		if relation in parents:
 			gen = "male"
 			if relation is "mother":
 				gen = "female"
 			tempNode =  Person(gen)
 			currentNode.addChild(tempNode, relation)
 		if relation in grandparents:
 			gen = "male"
 			if relation is "grandma" or relation is "grandmother":
 				gen = "female"
 			tempNode =  Person(gen)
 			currentNode.addChild(tempNode, relation)
 
 		if "cousin" in relation:
 			gen = "male"
 			if "sister" in relation:
 				gen = "female"
 			tempNode =  Person(gen)
 			currentNode.addCousin(tempNode, relation)
 
 		currentNode = tempNode
 
 	return (meNode, currentNode)
 
 #Finds relation in tuple(A, B)
 def digest(tree_tuple):
 	# Find the shortest path applicable and return it as an array
 	# Slightly modified version of the Graph traversal alogorithm
 	# This guy goes and checks only for applicable keys
 	relation_path = utils.NFA( tree_tuple[0], tree_tuple[1], looks_amongst = ["siblings", "kids.sons", "kids.daughters", "parent.mother", "parent.father"] )
 
 	# when the list is returned visit each node
 	# check what condition / relation the other node has
 	# until you form a chain
 	# first find indirect relations
 	# then the left direct relations
 	# name them and then print the string
 	relation = utils.NamedRelation(
 		direct_relations=direct_relations,
 		indirect_relations= indirect_relations,
 		lookup_key= "gender",
 		relation_path)
 	return relation
 
 relation = "My brother's wife's son's sister"
 tree = feedData(relation)
 
 #output is My neice
 print digest(tree)