including comex_install helper app in repo: it connects community.db queries...

including comex_install helper app in repo: it connects community.db queries to tinawebJS by extracting requested sql rows and converting them into json graphs (original author PkSM3)

.gitignore

@@ -8,7 +8,6 @@ src/*
 custom_sites/*
 less/*
 iscn/*
-comex_install/*
 script/*
 php/*.db
 static_regcomex/*

comex_install/FA2.py

+from Region import Region
+import ForceFactory
+import math
+import random
+import sys
+import pprint
+
+class ForceAtlas2:
+	def __init__(self,graph):
+		self.graph = graph
+		self.nodesIndex = {}
+		self.p={
+			"linLogMode": False,
+			"outboundAttractionDistribution": False,
+			"adjustSizes": False,
+			"edgeWeightInfluence": 0,
+			"scalingRatio": 1,
+			"strongGravityMode": False,
+			"gravity": 1,
+			"jitterTolerance": 1,
+			"barnesHutOptimize": False,
+			"barnesHutTheta": 1.2,
+			"speed": 1,
+			"outboundAttCompensation": 1,
+			"totalSwinging": 0,
+			"swingVSnode1": 0,
+			"totalEffectiveTraction": 0,
+			"complexIntervals": 500,
+			"simpleIntervals": 1000
+		}
+		self.state = {"step": 0, "index": 0}
+		self.rootRegion = 0
+
+	def init(self):
+		self.setAutoSettings()
+		nds = self.graph["nodes"]
+		for i in range(len(nds)):
+
+			if not nds[i].has_key("fixed"):
+				nds[i]['fixed'] = False
+
+			if not nds[i].has_key("x"):
+				nds[i]['x'] = random.uniform(0,1)
+
+			if not nds[i].has_key("y"):
+				nds[i]['y'] = random.uniform(0,1)
+
+			self.nodesIndex[nds[i]['id']] = i
+			nds[i]["fa2"] = {
+				"mass": 1+nds[i]["degree"],
+				"old_dx": 0,
+				"old_dy": 0,
+				"dx": 0,
+				"dy": 0
+			}
+		return self
+
+	def go(self):
+		while (self.atomicGo()):
+			print "something"
+
+	def printNodesFA2(self):
+		for i in self.graph["nodes"]:
+			print i
+
+	def setAutoSettings(self):
+		# Tuning
+		lenNodes = len(self.graph["nodes"])
+		if (lenNodes >= 100):
+			self.p["scalingRatio"] = 2.0
+		else:
+			self.p["scalingRatio"] = 10.0
+
+		self.p["strongGravityMode"] = False
+		self.p["gravity"] = 1
+
+		# Behavior
+		self.p["outboundAttractionDistribution"] = False
+		self.p["linLogMode"] = False
+		self.p["adjustSizes"] = False
+		self.p["edgeWeightInfluence"] = 1
+
+		# Performance
+		if (lenNodes >= 50000):
+			self.p["jitterTolerance"] = 10
+		elif (lenNodes >= 5000):
+			self.p["jitterTolerance"] = 1
+		else:
+			self.p["jitterTolerance"] = 0.1
+
+		if (lenNodes >= 1000):
+			self.p["barnesHutOptimize"] = True
+		else:
+			self.p["barnesHutOptimize"] = False
+
+		self.p["barnesHutTheta"] = 1.2
+
+
+
+
+	def atomicGo(self):
+		graph = self.graph
+		nodes = graph["nodes"]
+		edges = graph["edges"]
+
+		cInt = self.p["complexIntervals"]
+		sInt = self.p["simpleIntervals"]
+		
+		case = self.state["step"]
+
+		if   case==0:
+								# Initialise layout data
+			print "the case 0"
+			for i in range(len(nodes)):
+				if nodes[i]["fa2"]:
+					nodes[i]["fa2"]["mass"] = 1 + nodes[i]["degree"]
+					nodes[i]["fa2"]["old_dx"] = nodes[i]["fa2"]["dx"]
+					nodes[i]["fa2"]["old_dy"] = nodes[i]["fa2"]["dy"]
+					nodes[i]["fa2"]["dx"] = 0
+					nodes[i]["fa2"]["dy"] = 0
+				else:
+					nodes[i]["fa2"] = {
+						"mass": 1 + nodes[i]["degree"],
+						"old_dx": 0,
+						"old_dy": 0,
+						"dx": 0,
+						"dy": 0
+					}
+			
+			# If Barnes Hut active, initialize root region
+			if self.p["barnesHutOptimize"]:
+				print '\tcase 0 -> ["barnesHutOptimize"]'
+				self.rootRegion = Region(nodes, 0)
+				self.rootRegion.buildSubRegions()
+
+
+			# If outboundAttractionDistribution active, compensate.
+			if self.p["outboundAttractionDistribution"]:
+				print '\tcase 0 -> ["outboundAttractionDistribution"]'
+				self.p["outboundAttCompensation"] = 0
+				for i in range(len(nodes)):
+					self.p["outboundAttCompensation"] += nodes[i]["fa2"]["mass"]
+				self.p["outboundAttCompensation"] /= len(nodes)
+
+			self.state["step"] = 1
+			self.state["index"] = 0
+			return True
+
+
+		elif case==1:
+								# Repulsion
+			print "the case 1: Repulsion"
+			Repulsion = ForceFactory.buildRepulsion(self.p["adjustSizes"],self.p["scalingRatio"])
+			print "\tprinting what it is inside of Repulsion variable"
+			print Repulsion
+			if self.p["barnesHutOptimize"]:
+				rootRegion = self.rootRegion
+				barnesHutTheta = self.p["barnesHutTheta"]
+				i = self.state["index"]
+				while (i < len(nodes) and i < self.state["index"] + cInt):
+					n = nodes[i]
+					i+=1
+					if n["fa2"]:
+						rootRegion.applyForce(n, Repulsion, barnesHutTheta)
+				if (i == len(nodes)):
+					self.state["step"] = 2
+					self.state["index"] = 0
+				else:
+					self.state["index"] = i
+			else:
+				i1 = self.state["index"]
+				while (i1 < len(nodes) and i1 < self.state["index"] + cInt):
+					n1 = nodes[i1]
+					i1+=1
+					if n1["fa2"]:
+						for i2 in range(len(nodes)):
+							if i2 < i1 and nodes[i2]["fa2"]:
+								Repulsion.apply_nn(n1, nodes[i2])
+				if (i1 == len(nodes)):
+					self.state["step"] = 2
+					self.state["index"] = 0
+				else:
+					self.state["index"] = i1
+			return True
+
+
+		elif case==2:
+								# Gravity
+			print "the case 2: Gravity"
+			Gravity=""
+			if self.p["strongGravityMode"]:
+				Gravity = ForceFactory.getStrongGravity(self.p["scalingRatio"])
+			else:
+				Gravity = ForceFactory.buildRepulsion(self.p["adjustSizes"],self.p["scalingRatio"])
+			gravity = self.p["gravity"]
+			scalingRatio = self.p["scalingRatio"]
+			i = self.state["index"]
+			while (i < len(nodes) and i < self.state["index"] + sInt):
+				n = nodes[i]
+				i+=1
+				if n["fa2"]:
+					Gravity.apply_g(n, gravity / scalingRatio)
+
+			if (i == len(nodes)):
+				self.state["step"] = 3
+				self.state["index"] = 0
+			else:
+				self.state["index"] = i
+			return True
+
+		elif case==3:
+								# Attraction
+			print "the case 3: Attraction"
+			field=""
+			if self.p["outboundAttractionDistribution"]:
+				field = self.p["outboundAttCompensation"]
+			else:
+				field = 1
+			Attraction = ForceFactory.buildAttraction(self.p["linLogMode"],self.p["outboundAttractionDistribution"],self.p["adjustSizes"],1*field)
+			i = self.state["index"]
+			if self.p["edgeWeightInfluence"] == 0:
+				while (i < len(edges) and i < self.state["index"] + cInt):
+					e = edges[i]
+					i+=1
+					s = nodes[self.nodesIndex[e["source"]]]
+					t = nodes[self.nodesIndex[e["target"]]]
+					Attraction.apply_nn(s, t, 1)
+			elif self.p["edgeWeightInfluence"] == 1:
+				while (i < len(edges) and i < self.state["index"] + cInt):
+					e = edges[i]
+					i+=1
+					s = nodes[self.nodesIndex[e["source"]]]
+					t = nodes[self.nodesIndex[e["target"]]]
+					Attraction.apply_nn(s, t, (e["weight"] or 1))
+			else:
+				while (i < len(edges) and i < self.state["index"] + cInt):
+					e = edges[i]
+					i+=1
+					t = nodes[self.nodesIndex[e["target"]]]
+					Attraction.apply_nn(t,(math.pow(e["weight"] or 1), self.p["edgeWeightInfluence"]))
+			if (i == len(edges)):
+				self.state["step"] = 4
+				self.state["index"] = 0
+			else:
+				self.state["index"] = i
+			return True
+
+		elif case==4:
+								# Auto adjust speed
+			print "the case 4: Auto-adjust speed"
+			totalSwinging=0# How much irregular movement
+			totalEffectiveTraction = 0  # Hom much useful movement
+			swingingSum=0
+			promdxdy=0
+			for i in range(len(nodes)):
+				n = nodes[i]
+				fixed = n["fixed"] or False
+				if not fixed and n["fa2"]:
+					swinging = math.sqrt(math.pow(n["fa2"]["old_dx"] - n["fa2"]["dx"], 2)+math.pow(n["fa2"]["old_dy"] - n["fa2"]["dy"], 2))
+					totalSwinging+=n["fa2"]["mass"]*swinging
+					totalEffectiveTraction +=n["fa2"]["mass"]*0.5*math.sqrt(math.pow(n["fa2"]["old_dx"] + n["fa2"]["dx"], 2)+math.pow(n["fa2"]["old_dy"] + n["fa2"]["dy"], 2))
+			self.p["totalSwinging"] = totalSwinging
+			self.p["totalEffectiveTraction"] = totalEffectiveTraction
+			#We want that swingingMovement < tolerance * convergenceMovement
+			targetSpeed = math.pow(self.p["jitterTolerance"], 2)*self.p["totalEffectiveTraction"]/self.p["totalSwinging"]
+			#But the speed shoudn't rise too much too quickly,
+			#since it would make the convergence drop dramatically.
+			maxRise = 0.5
+			self.p["speed"] = self.p["speed"]+min(targetSpeed-self.p["speed"],maxRise * self.p["speed"])
+
+			#Save old coordinates
+			for i in range(len(nodes)):
+				nodes[i]["old_x"] = +nodes[i]["x"]
+				nodes[i]["old_y"] = +nodes[i]["y"]
+			self.state["step"] = 5
+			return True
+
+		elif case==5:
+								# Apply forces
+			print "the case 5: Apply forces"
+
+			i = self.state["index"]
+			if self.p["adjustSizes"]:
+				speed = self.p["speed"]
+				while (i < len(nodes) and i < self.state["index"] + sInt):
+					n = nodes[i]
+					i+=1
+					fixed = n["fixed"] or False
+					if not fixed and n["fa2"]:
+						swinging = math.sqrt((n["fa2"]["old_dx"] - n["fa2"]["dx"])*(n["fa2"]["old_dx"] - n["fa2"]["dx"]) +(n["fa2"]["old_dy"] - n["fa2"]["dy"])*(n["fa2"]["old_dy"] - n["fa2"]["dy"]))
+						factor = 0.1 * speed / (1 + speed * math.sqrt(swinging))
+						df = math.sqrt(math.pow(n["fa2"]["dx"], 2)+math.pow(n["fa2"]["dy"], 2))
+						factor = min(factor * df, 10) / df
+						n["x"] += n["fa2"]["dx"] * factor
+						n["y"] += n["fa2"]["dy"] * factor
+			else:
+				speed = self.p["speed"]
+				while (i < len(nodes) and i < self.state["index"] + sInt):
+					n = nodes[i]
+					i+=1
+					fixed = n["fixed"] or False
+					if not fixed and n["fa2"]:
+					#Adaptive auto-speed: the speed of each node is lowered
+					#when the node swings.
+						swinging = math.sqrt((n["fa2"]["old_dx"] - n["fa2"]["dx"])*(n["fa2"]["old_dx"] - n["fa2"]["dx"]) +(n["fa2"]["old_dy"] - n["fa2"]["dy"])*(n["fa2"]["old_dy"] - n["fa2"]["dy"]))
+						factor = speed / (1 + speed * math.sqrt(swinging))
+						n["x"] += n["fa2"]["dx"] * factor
+						n["y"] += n["fa2"]["dy"] * factor
+			if (i == len(edges)):
+				self.state["step"] = 0
+				self.state["index"] = 0
+				return False
+			else:
+				self.state["index"] = i
+				return True
+
+		else:
+								# Do the default
+			print "Error"
+			return False
+
+	def getGraph(self):
+		nds = self.graph['nodes']
+		justNodes = []
+		for i in range(len(nds)):
+			n = {
+				"id":i,
+				"sID":nds[i]["id"],
+				"x":nds[i]["x"],
+				"y":nds[i]["y"],
+				"occ":nds[i]["degree"]
+			}
+			justNodes.append(n)
+		return justNodes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

comex_install/ForceFactory.py

+import math
+
+def buildRepulsion(adjustBySize,coefficient):
+	if adjustBySize:
+		return linRepulsion_antiCollision(coefficient)
+	else:
+		return linRepulsion(coefficient)
+
+
+def getStrongGravity(coefficient):
+	return strongGravity(coefficient)
+
+def buildAttraction(logAttr,distributedAttr,adjustBySize,c):
+	if adjustBySize:
+		if logAttr:
+			if distributedAttr:
+				return logAttraction_degreeDistributed_antiCollision(c)
+			else:
+				return logAttraction_antiCollision(c)
+		else:
+			if distributedAttr:
+				return linAttraction_degreeDistributed_antiCollision(c)
+			else:
+				return linAttraction_antiCollision(c)
+	else:
+		if logAttr:
+			if distributedAttr:
+				return logAttraction_degreeDistributed(c)
+			else:
+				return logAttraction(c)
+		else:
+			if distributedAttr:
+				return linAttraction_massDistributed(c)
+			else:
+				return linAttraction(c)
+
+
+class linRepulsion:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1,n2):
+		if n1["fa2"] and n2["fa2"]:
+		#Get the distance
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor=self.coefficient * n1["fa2"]["mass"] * n2["fa2"]["mass"]/math.pow(distance, 2)
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+	def apply_nr(self,n,r):
+		#not used?
+		'''
+		xDist = n["x"] - r.config('massCenterX')
+		yDist = n["y"] - r.config('massCenterY')
+		distance = math.sqrt(xDist * xDist + yDist * yDist)
+		if (distance > 0):
+			factor = self.coefficient * n["fa2"]["mass"] * r.config('mass') /math.pow(distance, 2)
+			n["fa2"]["dx"] += xDist * factor
+			n["fa2"]["dy"] += yDist * factor
+		'''
+
+	def apply_g(self,n,g):
+		xDist = n["x"]
+		yDist = n["y"]
+		distance = math.sqrt(xDist*xDist + yDist*yDist)
+		if (distance > 0):
+          	#NB: factor = force / distance
+			factor = self.coefficient * n["fa2"]["mass"] * g / distance
+			n["fa2"]["dx"] -= xDist * factor
+			n["fa2"]["dy"] -= yDist * factor
+
+
+class linRepulsion_antiCollision:
+	def __init__(self,c):
+		self.coefficient = c
+
+	def apply_nn(self,n1,n2):
+		if n1["fa2"] and n2["fa2"]:
+		#Get the distance
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist) - n1["size"] - n2["size"]
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor=self.coefficient * n1["fa2"]["mass"] * n2["fa2"]["mass"]/math.pow(distance, 2)
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+			elif (distance < 0):
+				factor = 100 * self.coefficient * n1["fa2"]["mass"] * n2["fa2"]["mass"]
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+	def apply_nr(self,n,r):
+		#not used?
+		'''
+		xDist = n["x"] - r.config('massCenterX')
+		yDist = n["y"] - r.config('massCenterY')
+		distance = math.sqrt(xDist * xDist + yDist * yDist)
+		if (distance > 0):
+			factor = self.coefficient * n["fa2"]["mass"] * r.config('mass') /math.pow(distance, 2)
+			n["fa2"]["dx"] += xDist * factor
+			n["fa2"]["dy"] += yDist * factor
+		elif(distance<0):
+			factor = -self.coefficient * n["fa2"]["mass"] * r.getMass() / distance
+			n["fa2"]["dx"] += xDist * factor
+			n["fa2"]["dy"] += yDist * factor
+		'''
+
+	def apply_g(self,n,g):
+		xDist = n["x"]
+		yDist = n["y"]
+		distance = math.sqrt(xDist*xDist + yDist*yDist)
+		if (distance > 0):
+          	#NB: factor = force / distance
+			factor = self.coefficient * n["fa2"]["mass"] * g / distance
+			n["fa2"]["dx"] -= xDist * factor
+			n["fa2"]["dy"] -= yDist * factor
+
+class strongGravity:
+	def __init__(self,c):
+		self.coefficient = c
+
+	def apply_nn(self,n1,n2):
+		pass
+
+	def apply_nr(self,n,r):
+		pass
+
+	def apply_g(self,n,g):
+		xDist = n["x"]
+		yDist = n["y"]
+		distance = math.sqrt(xDist*xDist + yDist*yDist)
+		if (distance > 0):
+          	#NB: factor = force / distance
+			factor = self.coefficient * n["fa2"]["mass"] * g
+			n["fa2"]["dx"] -= xDist * factor
+			n["fa2"]["dy"] -= yDist * factor
+
+
+class linAttraction:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			factor = -self.coefficient * float(e)
+			n1["fa2"]["dx"] += xDist * factor
+			n1["fa2"]["dy"] += yDist * factor
+			n2["fa2"]["dx"] -= xDist * factor
+			n2["fa2"]["dy"] -= yDist * factor
+
+class linAttraction_massDistributed:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			factor = -self.coefficient * e / n1["fa2"]["mass"]
+
+			n1["fa2"]["dx"] += xDist * factor
+			n1["fa2"]["dy"] += yDist * factor
+			n2["fa2"]["dx"] -= xDist * factor
+			n2["fa2"]["dy"] -= yDist * factor
+
+class logAttraction:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e * math.log(1 + distance)/distance
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+class logAttraction_degreeDistributed:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e * math.log(1 + distance)/distance/n1["fa2"]["mass"]
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+class linAttraction_antiCollision:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+class linAttraction_degreeDistributed_antiCollision:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e / n1["fa2"]["mass"]
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+class logAttraction_antiCollision:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e * math.log(1 + distance)/distance
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+class logAttraction_degreeDistributed_antiCollision:
+	def __init__(self,c):
+		self.coefficient=c
+
+	def apply_nn(self,n1, n2, e):
+		if n1["fa2"] and n2["fa2"]:
+			xDist = n1["x"] - n2["x"]
+			yDist = n1["y"] - n2["y"]
+			distance = math.sqrt(xDist * xDist + yDist * yDist)
+
+			if (distance > 0):
+			#NB: factor = force / distance
+				factor = -self.coefficient * e * math.log(1 + distance)/distance/n1["fa2"]["mass"]
+				n1["fa2"]["dx"] += xDist * factor
+				n1["fa2"]["dy"] += yDist * factor
+				n2["fa2"]["dx"] -= xDist * factor
+				n2["fa2"]["dy"] -= yDist * factor
+
+
+

comex_install/README.md

+Flask
+simplejson
+gunicorn
+networkx

comex_install/RV-Uniform.py

+class RVUniformC:
+	def __init__(self,seed):
+		self.a=16807
+		self.b=0
+		self.m=2147483647
+		self.u=0
+		self.semilla=seed
+		self.x = self.semilla
+
+
+	def getRandom(self):
+		x = ((self.x*self.a)+self.b)%self.m
+		self.x = x
+		self.u = self.x/float(self.m)
+		return self.u
+
+
+#instancia = RVUniformC(100000000)
+#instancia.getUniform()

comex_install/Region.py

+import math
+
+class Region:
+
+	def __init__(self,nodes, depth):
+		#print "the atributes"		
+		self.depthLimit = 20
+		self.size = 0
+		self.nodes = nodes
+		self.subregions = []
+		self.depth = depth
+		self.p = { "mass": 0, "massCenterX": 0, "massCenterY": 0 }
+		self.updateMassAndGeometry()
+
+	def updateMassAndGeometry(self):
+		#print "updating mass and geometry"
+		nds = self.nodes
+		if len(nds) > 1:
+			mass=0
+			massSumX=0
+			massSumY=0
+			for n in range(len(nds)):
+				mass += nds[n]['fa2']['mass']
+				massSumX += nds[n]['x'] * nds[n]['fa2']['mass']
+				massSumY += nds[n]['x'] * nds[n]['fa2']['mass']
+
+			massCenterX = massSumX / mass
+			massCenterY = massSumY / mass
+			size=0
+			for n in range(len(nds)):
+				distance = math.sqrt( (nds[n]['x'] - massCenterX) *(nds[n]['x'] - massCenterX) +(nds[n]['y'] - massCenterY) *(nds[n]['y'] - massCenterY) )
+				size = max((self.size or (2 * distance)), 2 * distance)
+			
+			self.p['mass'] = mass;
+			self.p['massCenterX'] = massCenterX;nds
+			self.p['massCenterY'] = massCenterY;
+			self.size = size;
+
+
+
+	def buildSubRegions(self):
+		#print "buildSubRegions"
+		nds = self.nodes
+		if len(nds) > 1:
+			subregions = []
+			massCenterX = self.p['massCenterX']
+			massCenterY = self.p['massCenterY']
+			nextDepth = self.depth + 1
+			leftNodes = []
+			rightNodes = []
+			for n in range(len(nds)):
+				#nodesColumn = (nds[n]['x'] < massCenterX) ? (leftNodes) : (rightNodes);
+				if (nds[n]['x'] < massCenterX):	nodesColumn= leftNodes
+				else:	nodesColumn = rightNodes
+				nodesColumn.append(nds[n])
+			topleftNodes = []
+			bottomleftNodes = []
+			for n in range(len(nds)):
+				#nodesLine = (n.y() < massCenterY) ? (topleftNodes) : (bottomleftNodes);
+				if nds[n]['y'] < massCenterY:	nodesLine = topleftNodes
+				else:	nodesLine = bottomleftNodes
+				nodesLine.append(nds[n])
+
+			bottomrightNodes = []
+			toprightNodes = []
+			for n in range(len(nds)):
+				#nodesLine = (n.y() < massCenterY) ? (toprightNodes) : (bottomrightNodes);
+				if nds[n]['y'] < massCenterY:	nodesLine = toprightNodes
+				else:	nodesLine = bottomrightNodes
+				nodesLine.append(nds[n])
+
+			if (len(topleftNodes) > 0):
+				if (len(topleftNodes) < len(nds) and nextDepth <= self.depthLimit):
+					subregion = Region(topleftNodes,nextDepth)
+					subregions.append(subregion)
+				else:
+					for n in range(len(topleftNodes)):
+						oneNodeList = []
+						oneNodeList.append(topleftNodes[n])
+						subregion = Region(oneNodeList,nextDepth)
+						subregions.append(subregion)
+
+			if (len(bottomleftNodes) > 0):
+				if (len(bottomleftNodes) < len(nds) and nextDepth <= self.depthLimit):
+					subregion = Region(bottomleftNodes,nextDepth)
+					subregions.append(subregion)
+				else:
+					for n in range(len(bottomleftNodes)):
+						oneNodeList = []
+						oneNodeList.append(bottomleftNodes[n])
+						subregion = Region(oneNodeList,nextDepth)
+						subregions.append(subregion)
+
+			if (len(bottomrightNodes) > 0):
+				if (len(bottomrightNodes) < len(nds) and nextDepth <= self.depthLimit):
+					subregion = Region(bottomrightNodes,nextDepth)
+					subregions.append(subregion)
+				else:
+					for n in range(len(bottomrightNodes)):
+						oneNodeList = []
+						oneNodeList.append(bottomrightNodes[n])
+						subregion = Region(oneNodeList,nextDepth)
+						subregions.append(subregion)
+
+			if (len(toprightNodes) > 0):
+				if (len(toprightNodes) < len(nds) and nextDepth <= self.depthLimit):
+					subregion = Region(toprightNodes,nextDepth)
+					subregions.append(subregion)
+				else:
+					for n in range(len(toprightNodes)):
+						oneNodeList = []
+						oneNodeList.append(toprightNodes[n])
+						subregion = Region(oneNodeList,nextDepth)
+						subregions.append(subregion)
+
+			self.subregions = subregions
+			for i in range(len(subregions)):
+				subregions[i].buildSubRegions()
+
+
+
+			
+
+	def applyForce(self, n , Force , theta):
+		if len(self.nodes) < 2:
+			regionNode = self.nodes[0]
+			Force.apply_nn(n, regionNode)
+		else:
+			distance = math.sqrt((n["x"] - self.p["massCenterX"]) * (n["x"] - self.p["massCenterX"]) + (n["y"] - self.p["massCenterY"]) * (n["y"] - self.p["massCenterY"]))
+			if (distance * theta > self.size):
+				Force.apply_nr(n, self)
+			else:
+				for i in range(len(self.subregions)):
+					self.subregions[i].applyForce(n, Force, theta)
+

comex_install/__init__.py

+# -*- coding: utf-8 -*-

comex_install/comex.py

+# -*- coding: utf-8 -*-
+
+from FA2 import ForceAtlas2
+from extractDataCustom import extract as SQLite
+
+import sys
+reload(sys)
+sys.setdefaultencoding('utf-8')
+
+from flask import Flask
+from flask import request
+import simplejson as json
+app = Flask(__name__)
+
+
+@app.route("/")
+def main():
+
+#	try:
+
+	db=SQLite('../community.db')
+
+	if request.args.has_key("query"):
+		filteredquery = request.args['query']
+		scholars = db.getScholarsList("filter",filteredquery)
+		db.extract(scholars)
+	else:
+		unique_id = request.args['unique_id']
+		scholars = db.getScholarsList("unique_id",unique_id)
+		db.extract(scholars)
+	# < / Data Extraction > #
+	graphArray = db.buildJSON_sansfa2(db.Graph)
+	return json.dumps(graphArray)
+#	except Exception as err:
+#		return '{"error":"%s"}' % str(err)
+
+
+    
+
+#if __name__ == "__main__":
+#	app.run(port=8080)
+
+from reverseproxy import ReverseProxied
+app.wsgi_app = ReverseProxied(app.wsgi_app)

comex_install/converter.py

+# -*- encoding: utf-8 -*-
+
+import pprint as p
+import sqlite3
+
+class CountryConverter:
+	def __init__(self,dbname,dbtable,dbcolumnID,dbcolumnName):
+		
+		self.connDBLP=sqlite3.connect(dbname)
+		self.connDBLP.row_factory = sqlite3.Row# Magic line!
+		self.cursorDBLP=self.connDBLP.cursor()
+		self.dbname=dbname
+		self.dbtable=dbtable
+		self.dbcolumnID=dbcolumnID
+		self.dbcolumnName=dbcolumnName
+		self.ISO={}
+		self.dictISO={}
+		self.dictAlt={}
+
+	def searchCode(self,c):
+		C=c.upper()
+		if self.ISO.has_key(C):
+			return C
+		if self.dictISO.has_key(C):
+			return self.dictISO[C]
+		if self.dictAlt.has_key(C):
+			return self.dictAlt[C]
+
+
+	def getCountries(self,filename):
+		dadict={}
+		f = open(filename, 'r')
+		for d in f:
+			line=d.replace("\n","")
+			a=line.split("\t")
+			arr=[]
+			for j in range(1,len(a)):
+				if a[j] is not "":
+					arr.append(a[j])
+			code=a[0]
+			name=[]
+			if len(arr)==1:
+				name.append(a[1])
+			if len(arr)>1:
+				name=arr
+			dadict[code]=name
+		f.close()
+		return dadict
+
+	def createInvertedDicts(self,ISO,Alternatives):
+		self.ISO=ISO
+		for i in ISO:
+			self.dictISO[ISO[i][0].upper()]=i
+
+		for i in Alternatives:
+			a=Alternatives[i]
+			if len(a)>0:
+				for j in a:
+					self.dictAlt[j.upper()]=i
+
+
+	def convertAll(self,write):
+		dbtable=self.dbtable
+		dbcolumnName=self.dbcolumnName
+		dbcolumnID=self.dbcolumnID
+
+		if write:
+			query="ALTER TABLE "+dbtable+" ADD COLUMN norm_"+dbcolumnName+" char(250)"
+			self.cursorDBLP.execute(query)
+			self.connDBLP.commit()
+
+
+		query="SELECT "+dbcolumnID+","+dbcolumnName+" FROM "+dbtable
+		self.cursorDBLP.execute(query)
+		rows = self.cursorDBLP.fetchall()
+		total=len(rows)
+
+		fails={}
+		for i in rows:
+			# if write:
+			# 	q2='UPDATE '+dbtable+' SET norm_'+dbcolumnName+'="'+i[dbcolumnName]+'" WHERE '+dbcolumnID+'='+`i[dbcolumnID]`
+			# 	self.cursorDBLP.execute(q2)
+			# 	self.connDBLP.commit()
+	
+			ind=i[dbcolumnName].encode("UTF-8")
+			code=self.searchCode(ind)
+			if code:
+				if write:
+					q3='UPDATE '+dbtable+' SET norm_'+dbcolumnName+'="'+code+'" WHERE '+dbcolumnID+'='+`i[dbcolumnID]`
+					self.cursorDBLP.execute(q3)
+					self.connDBLP.commit()
+			else: fails[i[dbcolumnID]]=ind
+			print `i[dbcolumnID]`+" / "+`total`
+
+		self.connDBLP.close()	
+		return fails

comex_install/countries_ISO3166.txt

+AD	Andorra
+AE	United Arab Emirates
+AF	Afghanistan
+AL	Albania
+AM	Armenia
+AO	Angola
+AR	Argentina
+AT	Austria
+AU	Australia
+AZ	Azerbaijan
+BA	Bosnia and Herzegovina
+BD	Bangladesh
+BE	Belgium
+BF	Burkina Faso
+BG	Bulgaria
+BI	Burundi
+BJ	Benin
+BN	Brunei Darussalam
+BO	Plurinational State of Bolivia
+BR	Brazil
+BT	Bhutan
+BW	Botswana
+BY	Belarus
+BZ	Belize
+CA	Canada
+CD	The Democratic Republic of the Congo
+CF	Central African Republic
+CG	Congo
+CH	Switzerland
+CI	Ivory Coast
+CL	Chile
+CM	Cameroon
+CN	China
+CO	Colombia
+CR	Costa Rica
+CU	Cuba
+CY	Cyprus
+CZ	Czech Republic
+DE	Germany
+DJ	Djibouti
+DK	Denmark
+DO	Dominican Republic
+DZ	Algeria
+EC	Ecuador
+EE	Estonia
+EG	Egypt
+EH	Western Sahara
+ER	Eritrea
+ES	Spain
+ET	Ethiopia
+FI	Finland
+FJ	Fiji
+FK	Falkland Islands (Malvinas)
+FR	France
+GA	Gabon
+GB	United Kingdom
+GE	Georgia
+GF	French Guiana
+GH	Ghana
+GL	Greenland
+GM	Gambia
+GN	Guinea
+GQ	Equatorial Guinea
+GR	Greece
+GT	Guatemala
+GW	Guinea-Bissau
+GY	Guyana
+HN	Honduras
+HR	Croatia
+HT	Haiti
+HU	Hungary
+ID	Indonesia
+IE	Ireland
+IL	Israel
+IN	India
+IQ	Iraq
+IR	Islamic Republic of Iran
+IS	Iceland
+IT	Italy
+JM	Jamaica
+JO	Jordan
+JP	Japan
+KE	Kenya
+KG	Kyrgyzstan
+KH	Cambodia
+KP	Democratic People's Republic of Korea
+KR	Republic of Korea
+KW	Kuwait
+KZ	Kazakhstan
+LA	Lao People's Democratic Republic
+LB	Lebanon
+LK	Sri Lanka
+LR	Liberia
+LS	Lesotho
+LT	Lithuania
+LU	Luxembourg
+LV	Latvia
+LY	Libyan Arab Jamahiriya
+MA	Morocco
+MD	Republic of Moldova
+MG	Madagascar
+MK	The Former Yugoslav Republic of Macedonia
+ML	Mali
+MM	Myanmar
+MN	Mongolia
+MR	Mauritania
+MW	Malawi
+MX	Mexico
+MY	Malaysia
+MZ	Mozambique
+NA	Namibia
+NC	New Caledonia
+NE	Niger
+NG	Nigeria
+NI	Nicaragua
+NL	Netherlands
+NO	Norway
+NP	Nepal
+NZ	New Zealand
+OM	Oman
+PA	Panama
+PE	Peru
+PG	Papua New Guinea
+PH	Philippines
+PK	Pakistan
+PL	Poland
+PR	Puerto Rico
+PS	Occupied Palestinian Territory
+PT	Portugal
+PY	Paraguay
+QA	Qatar
+RO	Romania
+RS	Serbia
+RU	Russian Federation
+RW	Rwanda
+SA	Saudi Arabia
+SB	Solomon Islands
+SD	Sudan
+SE	Sweden
+SG	Singapore
+SI	Slovenia
+SJ	Svalbard and Jan Mayen
+SK	Slovakia
+SL	Sierra Leone
+SN	Senegal
+SO	Somalia
+SR	Suriname
+SV	El Salvador
+SY	Syrian Arab Republic
+SZ	Swaziland
+TD	Chad
+TG	Togo
+TH	Thailand
+TJ	Tajikistan
+TL	Timor-Leste
+TM	Turkmenistan
+TN	Tunisia
+TR	Turkey
+TW	Province of China Taiwan
+TZ	Tanzania
+UA	Ukraine
+UG	Uganda
+US	United States
+UY	Uruguay
+UZ	Uzbekistan
+VE	Bolivarian Republic of Venezuela
+VN	Viet Nam
+VU	Vanuatu
+XK	Kosovo
+YE	Yemen
+ZA	South Africa
+ZM	Zambia
+ZW	Zimbabwe

comex_install/countries_alternatives.txt

+AE	u arab emirates									
+AF	afghanistan									
+AL										
+AM	armenia									
+AO										
+AR	argentina									
+AT	austria									
+AU	australia	Norfolk Island								
+AZ										
+BA	bosnia and herzegovina									
+BD	bangladesh									
+BE	belgium									
+BF	burkina faso									
+BG	bulgaria									
+BI	burundi									
+BJ	benin									
+BN										
+BO	la paz - bolivia	Bolivia								
+BR	883 fundos sidil divinópolis mg brasil	rua meaipe . condominio valparaiso i. bloco c1. apt 204. laranjeiras - serra- es	rua itapecerica	avenida josé assis de vasconcelos	brazil	brasil	viçosa mg	325 - bethânia - ipatinga - minas gerais - brasil	rio de janeiro	883 sidil divinópolis mg brasil
+BT										
+BW	botswana	btbswb								
+BY	belarus									
+BZ										
+CA	canada									
+CD										
+CF										
+CG	democratic republic of the congo	democratic republic of congo	congo democratic republic of							
+CH	switzerland	geneva								
+CI										
+CL	chile									
+CM	cameroun	cameroon								
+CN	shanghai	china	hong kong	中国						
+CO	colombia									
+CR	costa rica									
+CU										
+CY										
+CZ										
+DE	germany									
+DJ										
+DK	denmark									
+DO	dominican republic									
+DZ										
+EC										
+EE										
+EG	egypt									
+EH										
+ER										
+ES	spain									
+ET	ethiopia									
+FI										
+FJ										
+FK										
+FR	france	guadeloupe	ile de france							
+GA										
+GB	united kingdom	united kingdon	england	u.k.	uk	britain				
+GE										
+GF										
+GH	ghana	accraghana								
+GL										
+GM	the gambia									
+GN										
+GQ										
+GR	greece									
+GT	guatemala	guatemala city								
+GW										
+GY										
+HN	honduras									
+HR										
+HT	haiti									
+HU										
+ID	yogyakarta	indonesia								
+IE	ireland									
+IL	israel									
+IN	184-1 thiruvikanagar street	tamilnadu st.india	184/1 thiruvikanagar .harur tk.dharmapuri.tamilnadu st	dist.udalguri.p.o. dimakuchi.vill.no 2 sonajuli	dharmapuri dt	nagaland india	harur tk & po	state assam	india	
+IQ										
+IR	iran									
+IS										
+IT	italy									
+JM										
+JO	jordan									
+JP										
+KE	kenyan	kenya	kenya.							
+KG	kyrgyzstan									
+KH	cambodia									
+KP										
+KR	south korea									
+KW										
+KZ										
+LA										
+LB	lebanon									
+LK	sri lanka									
+LR										
+LS										
+LT	lithuania									
+LU	Luxemburg									
+LV										
+LY										
+MA										
+MD	moldova									
+MG										
+MK	macedonia									
+ML	mali									
+MM										
+MN										
+MR										
+MW	malawi									
+MX	dona ana	méxico	osvaldoalbuquerque65@hotmail.com	mexico						
+MY	malaysia									
+MZ	mozambique									
+NA	namibia									
+NC										
+NE										
+NG	abuja-nigeria	nigeria	nigeria/australia							
+NI										
+NL	the netherlands and egypt	netherlands	the netherlands							
+NO	norway									
+NP	nepal									
+NZ	new zealand									
+OM	oman									
+PA	panama									
+PE	peru									
+PG	papua new guinea									
+PH	philippines									
+PK	pakistan									
+PL										
+PR										
+PS	palestine									
+PT										
+PY	paraguay									
+QA	qatar									
+RO	romania									
+RS	republic of serbia	serbia								
+RU	russian federation									
+RW	rwanda									
+SA										
+SB										
+SD										
+SE	sverige	sweden								
+SG	singapore									
+SI	slovenia									
+SJ										
+SK										
+SL										
+SN										
+SO	somalia	united state somalia diaspora								
+SR										
+SV	el salvador									
+SY										
+SZ	swaziland									
+TD										
+TG	togo									
+TH	thailand									
+TJ										
+TL										
+TM										
+TN										
+TR	uftu	turkey								
+TW	taiwan									
+TZ	tanzania in east africa	tanzania	usa & tanzania							
+UA	Украина.Одесса									
+UG	uganda-africa	uganda								
+US	united state of america	united states of america	17 dennison st	usa	united states	atlanta ga	waltham ma	us	u.s.a.	america
+UY										
+UZ										
+VE	venezuela									
+VN	vietnam									
+VU										
+XK	kosovo									
+YE										
+ZA	republic of south africa	south africa								
+ZM	zambia and south africa	zambia								
+ZW	zimbabwe									

comex_install/main.py

+# -*- coding: utf-8 -*-
+
+from FA2 import ForceAtlas2
+from extractDataCustom import extract as SQLite
+
+import sys
+reload(sys)
+sys.setdefaultencoding('utf-8')
+
+from flask import Flask
+from flask import request
+import simplejson as json
+app = Flask(__name__)
+
+
+@app.route("/getJSON")
+def main():
+
+	db=SQLite('../community.db')
+	
+	if request.args.has_key("query"):
+		filteredquery = request.args['query']
+		scholars = db.getScholarsList("filter",filteredquery)
+		db.extract(scholars)
+	else:
+		unique_id = request.args['unique_id']
+		scholars = db.getScholarsList("unique_id",unique_id)
+		db.extract(scholars)
+	# < / Data Extraction > #
+
+	graphArray = db.buildJSON_sansfa2(db.Graph)
+	return json.dumps(graphArray)
+
+
+    
+
+if __name__ == "__main__":
+	app.run(port=8080)

comex_install/reversal.py

+class ReverseProxied(object):
+    def __init__(self, app):
+        self.app = app
+
+    def __call__(self, environ, start_response):
+        script_name = environ.get('HTTP_X_SCRIPT_NAME', '')
+        if script_name:
+            environ['SCRIPT_NAME'] = script_name
+            path_info = environ['PATH_INFO']
+            if path_info.startswith(script_name):
+                environ['PATH_INFO'] = path_info[len(script_name):]
+
+        scheme = environ.get('HTTP_X_SCHEME', '')
+        if scheme:
+            environ['wsgi.url_scheme'] = scheme
+        return self.app(environ, start_response)

comex_install/reverseproxy.py

+class ReverseProxied(object):
+
+    def __init__(self, app):
+        self.app = app
+
+    def __call__(self, environ, start_response):
+        script_name = environ.get('HTTP_X_SCRIPT_NAME', '')
+        if script_name:
+            environ['SCRIPT_NAME'] = script_name
+            path_info = environ['PATH_INFO']
+            if path_info.startswith(script_name):
+                environ['PATH_INFO'] = path_info[len(script_name):]
+
+        scheme = environ.get('HTTP_X_SCHEME', '')
+        if scheme:
+            environ['wsgi.url_scheme'] = scheme
+        return self.app(environ, start_response)