def login(account):
# Read user info
try:
arr = account.split('|')
if len(arr) >= 2:
username = arr[0]
password = arr[1]
except Exception as error:
write_to_log("Failed to read " + account, error, sys.exc_info())
# Login
proxy = Proxy.Proxy()
proxy = proxy.get_proxy()
url = 'https://de.lovoo.com/login_check'
session = requests.Session()
try:
payload = {'_username': username,
'_password': password,
'_remember_me': 'false'
}
# header = {'user-agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
# 'Chrome/71.0.3578.98 Safari/537.36'}
# response = sess.get(url, data=data, headers=header, proxies=proxy)
response = session.post(url, data=payload, proxies={'http': proxy})
json = response.json()
if json['success']:
print('Successfully logged in')
return session
else:
print(json['message'])
except Exception as error:
print(error)
def system_initial(config_file, Nodes, Proxies):
print('System Initialing...')
config_file = open(config_path, 'r')
Node_Number = 0
Node_IP = []
Node_Port = []
for eachline in config_file.readlines():
if eachline[:12] == 'Node_Number=':
Node_Number = eachline[12:].strip('{}\n')
Node_Number = int(Node_Number)
if eachline[:18] == 'Nodes_Information=':
temp = eachline[18:].strip('{}\n')
temp = temp.split(';')
for i in range(Node_Number):
ip, port = temp[i].strip('[]').split(',')
ip = ip.strip("''")
port = port.strip("''")
Node_ID = 'Node_%d' % (i)
Proxy_ID = 'Proxy_%d' % (i)
try:
Nodes.append(
Client((ip, int(port)),
authkey=bytes(str(Node_ID), encoding='utf8')))
try:
Proxies.append(Proxy.RPCProxy(Nodes[i]))
except Exception as e1:
print(str(Node_ID) + ':')
raise e1
except Exception as e2:
print(str(Node_ID) + ':')
raise e2
print('Initial Completed. Now You have %d Nodes to Use.' % (len(Nodes)))
def main():
ip = 'localhost'
port = 9090
print "Inicio del proxy"
server = Proxy.Proxy(ip, port)
print "Servidor proxy iniciado en la IP", ip, "y puerto", port
server.start()
def __init__(self):
print('Сбор доступных прокси')
proxy = Proxy.Proxy()
self.proxy_list = proxy.get_proxy()
self.PROXY_LEN = len(self.proxy_list)
self.user_agents = open('user-agent-list.txt').read().split('\n')
d = date.today()
date_file_name = str(d.year) + '-' + str(d.month) + '-' + str(d.day)
os.chdir(os.path.dirname(__file__))
self.proxy_f_name = os.getcwd() + 'proxies_' + date_file_name + '.txt'
def Create_Proxy():
if cmds.objExists('hidden')==False:
checkbox_Proxy_Layout= cmds.checkBox(Check_Proxy_Layout, q=True, v=True)
if checkbox_Proxy_Layout==True:
Scale_Guide=cmds.xform('Guide_Ctrl_Master',ws=True, q=True, s=True )
cmds.group(n='Guide_Scale_Grp',em=True)
cmds.select(cl=True)
cmds.xform('Guide_Scale_Grp',ws=True,s=Scale_Guide)
cmds.file(PathCtrls_Proxy,i=True)
Scale('Guide_Ctrl_Master','Set_Ctrls_Proxy')
Proxy.Base_Rig()
cmds.parent('Guide_Scale_Grp','hidden')
cmds.select(cl=True)
else:
cmds.warning( "NO SELECCIONASTE EL CHECKBOX DE PROXY!!!" )
else:
cmds.warning( "EL RIG_PROXY YA ESTA CREADO!!!" )
def test_proxy_desktop(self):
desktop_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
proxy = Proxy.Interface()
proxy_thread = threading.Thread(target = proxy.start_server)
proxy_thread.start()
#connect
desktop_client.connect(('127.0.0.1',50222))
#gather the init message
who_response = desktop_client.recv(100).decode("ascii")
#should be who are you
self.assertEqual(who_response , "WHO_ARE_YOU")
#claim desktop
desktop_client.send("DESKTOP".encode("ascii"))
#recv response
status_response = desktop_client.recv(100).decode("ascii")
#should be waiting on raspberry pi
self.assertEqual(status_response , "AWAITING_PI")
#close sockets
desktop_client.close()
proxy.running = False
proxy.server.close()
return controller.getControlParamsCount() + 1
cls = Core.SimBiController
SimBiController = Proxy.create(
cls,
caster=Core.castToSimBiController,
loader=wx.GetApp().addController,
nameGetter=cls.getName,
icon="../data/ui/controllerIcon.png",
members=[
Member.Basic(str, 'name', 'UnnamedSimBiController', cls.getName,
cls.setName),
Member.Basic(int, 'startingState', 0, cls.getStartingState,
cls.setStartingState),
Member.Basic(float, 'stanceHipDamping', 25, cls.getStanceHipDamping,
cls.setStanceHipDamping),
Member.Basic(float, 'stanceHipMaxVelocity', 4,
cls.getStanceHipMaxVelocity, cls.setStanceHipMaxVelocity),
Member.ObjectList('controlParamsList', None, getControlParams,
getControlParamsCount, cls.addControlParams),
Member.ObjectList('states',
None,
cls.getState,
cls.getStateCount,
cls.addState,
embedInParentNode=True)
])
def setJoint(joint, jointName, controller):
if not joint.setJoint(controller.getCharacter().getJointByName(jointName)):
reload(sys)
sys.setdefaultencoding('utf-8')
class CrawlJD(threading.Thread,JD.JD_crawl):
def __init__(self,sets=set(),num = 1):
threading.Thread.__init__(self)
JD.JD_crawl.__init__(self)
self.crawl_set = sets
self.num_of_thread = num
def run(self):
for i in self.crawl_set:
self.crawl_from_catalog(i[0],i[1])
proxy = Proxy.crawl_Proxy()
list = proxy.crawl_proxy(10)
for i in list:
print i[0] + " " + str(i[1])
'''
jd = CrawlJD()
threads = jd.create_class("JD",6)
sets = jd.seprate_set(jd.crawl_sort_page(),6)
combined =zip(threads, sets)
for thread,set in combined:
thread = CrawlJD(set)
thread.start()
'''
'''
Created on 2009-09-02
@author: beaudoin
'''
import Proxy, Member
import App
cls = App.ObservableList
ObservableList = Proxy.create( cls,
members = [
Member.ObjectList( 'objects', None, cls.get, cls.getCount, cls.add, embedInParentNode = True ),
] )
cls = App.SnapshotBranch
SnapshotBranch = Proxy.create( cls,
nameGetter = lambda object: "Branch",
icon = "../data/ui/snapshotBranch.png",
members = [
Member.ObjectList( 'snapshots', None, cls.getSnapshot, cls.getSnapshotCount, None, embedInParentNode = True ),
] )
cls = App.Snapshot
Snapshot = Proxy.create( cls,
nameGetter = cls.getName,
icon = "../data/ui/snapshotIcon.png",
members = [
Member.ObjectList( 'branches', None, cls.getBranch, cls.getBranchCount, None, embedInParentNode = True ),
] )
def Client():
while 1:
fileName = raw_input("Enter the name of the file you want access to: ")
Proxy.Proxy(fileName)
'''
Created on 2009-09-02
@author: beaudoin
'''
import Proxy
import Member
import Physics
cls = Physics.SphereCDP
SphereCDP = Proxy.create(cls,
verbose=False,
caster=Physics.castToSphereCDP,
members=[
Member.Point3d('center', (0.0, 0.0, 0.0),
cls.getCenter, cls.setCenter),
Member.Basic(float, 'radius', 1.0, cls.getRadius,
cls.setRadius),
])
cls = Physics.BoxCDP
BoxCDP = Proxy.create(cls,
verbose=False,
caster=Physics.castToBoxCDP,
members=[
Member.Point3d('point1', (-1.0, -1.0, -1.0),
cls.getPoint1, cls.setPoint1),
Member.Point3d('point2', (1.0, 1.0, 1.0),
cls.getPoint2, cls.setPoint2),
])
def getControlParams(controller, i):
if i == 0 :
return controller.getRootControlParams()
else :
return controller.getControlParams(i-1)
def getControlParamsCount(controller):
return controller.getControlParamsCount() + 1
cls = Core.SimBiController
SimBiController = Proxy.create( cls, caster = Core.castToSimBiController, loader = wx.GetApp().addController,
nameGetter = cls.getName,
icon = "../data/ui/controllerIcon.png",
members = [
Member.Basic( str, 'name', 'UnnamedSimBiController', cls.getName, cls.setName ),
Member.Basic( int, 'startingState', 0, cls.getStartingState, cls.setStartingState ),
Member.Basic( float, 'stanceHipDamping', 25, cls.getStanceHipDamping, cls.setStanceHipDamping ),
Member.Basic( float, 'stanceHipMaxVelocity', 4, cls.getStanceHipMaxVelocity, cls.setStanceHipMaxVelocity ),
Member.ObjectList( 'controlParamsList', None, getControlParams, getControlParamsCount, cls.addControlParams ),
Member.ObjectList( 'states', None, cls.getState, cls.getStateCount, cls.addState, embedInParentNode = True )
] )
def setJoint(joint, jointName, controller):
if not joint.setJoint( controller.getCharacter().getJointByName(jointName) ):
raise ValueError( "Setting the wrong joint." )
cls = Core.ControlParams
ControlParams = Proxy.create( cls, caster = Core.castToControlParams,
nameGetter = cls.getJointName,
icon = "../data/ui/controlParamsIcon.png",
members = [
def cli(master_server, client_servers):
while True:
try:
cmd = input("$ ").decode("utf-8")
cmd = list(map(lambda s: s.replace("\n", ""), cmd.split(" ")))
if (cmd[0] == "quit" or cmd[0] == "exit"):
os._exit(0)
elif (cmd[0] == "help"):
print("--Commands--")
for key, val in cmds.items():
log.info("{} :: {}".format(key, val))
print("--Commands--")
elif (cmd[0] == "setserver"):
if (len(cmd) != 4):
log.warn(
"Error: Command format is \"setserver <interface> <ip> <port>\""
)
else:
if (not master_server):
master_server = Proxy(cmd[1], cmd[2], int(cmd[3]))
master_server.start()
log.info(
"[> Started server connection: [ip {}] [port{}]".
format(cmd[2], cmd[3]))
else:
log.warn(
"Error: Server connection already established, close with \"server -c\""
)
elif (cmd[0] == "setclient"):
if (len(cmd) != 4):
print(
"Error: Command format is \"setclient <interface> <ip> <port>\""
)
else:
client = Proxy(cmd[1], cmd[2], cmd[3])
client.start()
client_servers.append(client)
log.info("[> Started client connection: [ip {}] [port{}]".
format(cmd[2], cmd[3]))
elif (cmd[0] == "client"):
if (len(cmd) < 2):
log.warn("Error: Command format is \"client <flags>\"")
else:
if ("-ca" in cmd):
for client in client_servers:
client.close()
client_servers.remove(clients)
log.info("[> Closed all open clients")
if ("-ci" in cmd):
index = cmd.index("-ci")
if (index >= len(cmd) - 1):
log.warn(
"Error: \"-ci\" flag must have an id specified"
)
else:
len_pre = len(client_servers)
for client in client_servers:
if (str(client.getClientUid()) == cmd[index +
1]):
client.close()
client_servers.remove(client)
break
if (len_pre == len(client_servers)):
log.warn(
"Error: No open client with id: {}".format(
cmd[index + 1]))
log.info("[> Closed client with id: {}".format(
cmd[index + 1]))
if ("-i" in cmd):
index = cmd.index("-i")
if (index >= len(cmd) - 1):
log.warn(
"Error: \"-i\" flag must have an id specified")
else:
for client in client_servers:
if (str(client.getClientUid()) == cmd[index +
1]):
log.info(
"[> Client " + text.bold_yellow(
str(client.getClientUid())) +
"\nInterface: {}\nServer IP: {}\nPort: {}"
.format(client.getInterface(),
client.getServer(),
client.getPort()))
break
if ("-ids" in cmd):
if (len(client_servers) < 1):
log.warn("Error: No active clients")
else:
log.info("[> Active Clients")
for i in range(0, len(client_servers)):
logging.listelem(
str(i), client_servers[i].getClientUid())
if ("-if" in cmd):
index = cmd.index("-if")
if (len(cmd) - 1 == index):
log.warn(
"Error: flag must have an interface specified")
else:
changed = False
for client in client_servers:
if (str(client.getClientUid()) == cmd[index +
1]):
client.from_host = cmd[index + 2]
log.info(
"[> Set client interface to: '{}'".
format(cmd[index + 2]))
changed = True
break
if (not changed):
log.warn("Error: No client with id: " +
cmd[index + 1])
elif (cmd[0] == "server"):
if (len(cmd) < 2):
log.warn("Error: Command format is \"server <flags>\"")
else:
if ("-c" in cmd):
master_server.close()
log.info("[> Closed active server connection")
if ("-p" in cmd):
index = cmd.index("-p")
if (len(cmd) - 1 == index):
log.warn("Error: flag must have a port specified")
else:
master_server.port = int(cmd[index + 1])
log.info("[> Set server port to: '{}'".format(
cmd[index + 1]))
if ("-i" in cmd):
log.info("[> Server " + text.bold_yellow(
str(master_server.getServerUid())) +
"\nInterface: {}\nIP: {}\nPort: {}".format(
master_server.getInterface(),
master_server.getServer(),
master_server.getPort()))
if ("-if" in cmd):
index = cmd.index("-if")
if (len(cmd) - 1 == index):
log.warn(
"Error: flag must have an interface specified")
else:
master_server.from_host = cmd[index + 1]
log.info("[> Set server interface to: '{}'".format(
cmd[index + 1]))
else:
log.warn(
"Error: Invalid command, type \"help\" for a list of commands"
)
except Exception as e:
print(e.message)
logging.error(e)
def setChild(joint, arbName, af):
joint.setChild( getArb(af,arbName) )
def getParent(joint):
return joint.getParent().getName()
def getChild(joint):
return joint.getChild().getName()
cls = Physics.Joint
Joint = Proxy.create( cls,
members = [
Member.Basic( str, 'name', 'UnnamedJoint', cls.getName, cls.setName ),
Member.Basic( str, 'parent', None, getParent, setParent ),
Member.Basic( str, 'child', None, getChild, setChild ),
Member.Point3d( 'posInParent', (0.0,0.0,0.0), cls.getParentJointPosition, cls.setParentJointPosition ),
Member.Point3d( 'posInChild', (0.0,0.0,0.0), cls.getChildJointPosition, cls.setChildJointPosition )
] )
cls = Physics.BallInSocketJoint
BallInSocketJoint = Proxy.create( cls, parent = Joint, caster = Physics.castToBallInSocketJoint,
members = [
Member.Vector3d( 'swingAxis1', (1.0,0.0,0.0), cls.getSwingAxis1, cls.setSwingAxis1 ),
Member.Vector3d( 'swingAxis2', None, cls.getSwingAxis2, cls.setSwingAxis2 ),
Member.Vector3d( 'twistAxis', None, cls.getTwistAxis, cls.setTwistAxis ),
Member.Tuple( 'limits', (-3.1416,3.1416,-3.1416,3.1416,-3.1416,3.1416), None, cls.setJointLimits )
] )
cls = Physics.UniversalJoint
def setChild(joint, arbName, af):
joint.setChild( getArb(af,arbName) )
def getParent(joint):
return joint.getParent().getName()
def getChild(joint):
return joint.getChild().getName()
cls = Physics.Joint
Joint = Proxy.create( cls,
members = [
Member.Basic( str, 'name', 'UnnamedJoint', cls.getName, cls.setName ),
Member.Basic( str, 'parent', None, getParent, setParent ),
Member.Basic( str, 'child', None, getChild, setChild ),
Member.Point3d( 'posInParent', (0.0,0.0,0.0), cls.getParentJointPosition, cls.setParentJointPosition ),
Member.Point3d( 'posInChild', (0.0,0.0,0.0), cls.getChildJointPosition, cls.setChildJointPosition )
] )
cls = Physics.BallInSocketJoint
BallInSocketJoint = Proxy.create( cls, parent = Joint, caster = Physics.castToBallInSocketJoint,
members = [
Member.Vector3d( 'swingAxis1', (1.0,0.0,0.0), cls.getSwingAxis1, cls.setSwingAxis1 ),
Member.Vector3d( 'swingAxis2', None, cls.getSwingAxis2, cls.setSwingAxis2 ),
Member.Vector3d( 'twistAxis', None, cls.getTwistAxis, cls.setTwistAxis ),
Member.Tuple( 'limits', (-3.1416,3.1416,-3.1416,3.1416,-3.1416,3.1416), None, cls.setJointLimits )
] )
cls = Physics.UniversalJoint
def main():
context = zmq.Context()
run_children(context, 3)
controller = Proxy.Controller(context)
controller.run()
import Proxy
reload(sys)
sys.setdefaultencoding('utf-8')
class CrawlJD(threading.Thread, JD.JD_crawl):
def __init__(self, sets=set(), num=1):
threading.Thread.__init__(self)
JD.JD_crawl.__init__(self)
self.crawl_set = sets
self.num_of_thread = num
def run(self):
for i in self.crawl_set:
self.crawl_from_catalog(i[0], i[1])
proxy = Proxy.crawl_Proxy()
list = proxy.crawl_proxy(10)
for i in list:
print i[0] + " " + str(i[1])
'''
jd = CrawlJD()
threads = jd.create_class("JD",6)
sets = jd.seprate_set(jd.crawl_sort_page(),6)
combined =zip(threads, sets)
for thread,set in combined:
thread = CrawlJD(set)
thread.start()
'''
#!/usr/bin/python3.3
import Cerveau
import Securite
import System
import Reload
import Server
import threading
import time
import builtins
import Mail
import time
import Proxy
import Config
if __name__ == '__main__':
Proxy.connectProxy("http")
starttime=time.time()
print("Initialisation en cours")
HOST, PORT = Config.address, Config.port
LS = Server.ThreadedTCPServer((HOST, PORT), Server.ThreadedTCPRequestHandler)
Securite.init()
Cerveau.init()
builtins.init=0
server_thread = threading.Thread(target=LS.serve_forever)
server_thread.start()
print("initialisation réalisé en "+str(time.time()-starttime)+"sec")
print('Serving')
# a=System.MyMonitoringThread('Monitoring')
# a.start()
b=threading.Thread(None,Reload.verify,None)
b.start()
'''
Created on 2009-09-03
@author: beaudoin
'''
import Proxy
import Member
import Physics, Core, wx
cls = Physics.ArticulatedFigure
ArticulatedFigure = Proxy.create( cls, loader = Physics.world().addArticulatedFigure,
members = [
Member.Basic( str, 'name', 'UnnamedArticulatedFigure', cls.getName, cls.setName ),
Member.Object( 'root', None, cls.getRoot, cls.setRoot ),
Member.ObjectList( 'arbs', None, cls.getArticulatedRigidBody, cls.getArticulatedRigidBodyCount, cls.addArticulatedRigidBody ),
Member.ObjectList( 'joints', None, cls.getJoint, cls.getJointCount, cls.addJoint )
] )
cls = Core.Character
Character = Proxy.create( cls, parent = ArticulatedFigure, loader = wx.GetApp().addCharacter )
import os, sys
import random
import numpy as np
from PySide2.QtCore import QUrl, Qt, QCoreApplication
from PySide2.QtWidgets import QApplication
from PySide2.QtQml import QQmlApplicationEngine
from PySide2.QtCore import QObject, Signal, Slot, Property
from PySide2.QtCore import QAbstractListModel, QAbstractTableModel, QModelIndex, QByteArray
from Proxy import *
if __name__ == '__main__':
QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
app = QApplication(sys.argv)
proxy = Proxy()
engine = QQmlApplicationEngine()
engine.rootContext().setContextProperty("proxy", proxy)
engine.load(
QUrl.fromLocalFile(
os.path.join(os.path.dirname(sys.argv[0]), "Gui.qml")))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
import Auth, Proxy
import Container
id = Auth.Auth().get_user_id()
proxy = Proxy.Proxy(id)
proxy.create_group('Group1')
#permission = {}
#proxy.edit_group_stat(stat_name='permission', stat_value=permission, stat_opt='Dict')
print "Finally of create group we have GroupData with permission to invite new peuple for creator," \
"We create ObjectData it's user who create a group"
print Container.GROUP_CONTAINER.container, Container.GROUP_CONTAINER.container[
'123Group1'].permission
print Container.USER_CONTAINER.container, Container.USER_CONTAINER.container[
'123Group1123']._roles
#proxy.edit_group_stat(permission, stat_opt, name)
cls = Physics.RigidBody
RigidBody = Proxy.create(
cls,
loader=Physics.world().addRigidBody,
members=[
Member.Basic(str, "name", "UnnamedRigidBody", cls.getName, cls.setName),
Member.Basic(list, "meshes", None, getMeshes, setMeshes),
Member.Basic(float, "mass", 1.0, cls.getMass, cls.setMass),
Member.Vector3d("moi", (1.0, 1.0, 1.0), cls.getMOI, cls.setMOI),
Member.ObjectList(
"cdps",
None,
cls.getCollisionDetectionPrimitive,
cls.getCollisionDetectionPrimitiveCount,
cls.addCollisionDetectionPrimitive,
),
Member.Point3d("pos", (0.0, 0.0, 0.0), cls.getCMPosition, cls.setCMPosition),
Member.Vector3d("vel", (0.0, 0.0, 0.0), cls.getCMVelocity, cls.setCMVelocity),
Member.Quaternion("orientation", (0.0, (1.0, 0.0, 0.0)), cls.getOrientation, cls.setOrientation),
Member.Vector3d("angularVel", (0.0, 0.0, 0.0), cls.getAngularVelocity, cls.setAngularVelocity),
Member.Basic(bool, "locked", False, cls.isLocked, cls.lockBody),
Member.Basic(float, "frictionCoeff", 0.8, cls.getFrictionCoefficient, cls.setFrictionCoefficient),
Member.Basic(float, "restitutionCoeff", 0.35, cls.getRestitutionCoefficient, cls.setRestitutionCoefficient),
Member.Basic(tuple, "groundCoeffs", (0.00001, 0.2), getGroundCoeffs, setGroundCoeffs),
Member.Basic(bool, "planar", False, cls.isPlanar, cls.setPlanar),
],
)
cls = Physics.ArticulatedRigidBody
ArticulatedRigidBody = Proxy.create(
'''
Created on 2009-09-02
@author: beaudoin
'''
import Proxy, Member
import App
cls = App.ObservableList
ObservableList = Proxy.create( cls,
members = [
Member.ObjectList( 'objects', None, cls.get, cls.getCount, cls.add, embedInParentNode = True ),
] )
cls = App.SnapshotBranch
SnapshotBranch = Proxy.create( cls,
nameGetter = lambda object: "Branch",
icon = "../data/ui/snapshotBranch.png",
members = [
Member.ObjectList( 'snapshots', None, cls.getSnapshot, cls.getSnapshotCount, None, embedInParentNode = True ),
] )
cls = App.Snapshot
Snapshot = Proxy.create( cls,
nameGetter = cls.getName,
icon = "../data/ui/snapshotIcon.png",
members = [
Member.ObjectList( 'branches', None, cls.getBranch, cls.getBranchCount, None, embedInParentNode = True ),
] )
def getGroundCoeffs(object):
return (object.getGroundSoftness(), object.getGroundPenalty())
def setGroundCoeffs(object, value):
return object.setODEGroundCoefficients(*value)
cls = Physics.RigidBody
RigidBody = Proxy.create( cls, loader = Physics.world().addRigidBody,
members = [
Member.Basic( str, 'name', 'UnnamedRigidBody', cls.getName, cls.setName ),
Member.Basic( list, 'meshes', None, getMeshes, setMeshes ),
Member.Basic( float, 'mass', 1.0, cls.getMass, cls.setMass ),
Member.Vector3d( 'moi', (1.0,1.0,1.0), cls.getMOI, cls.setMOI ),
Member.ObjectList( 'cdps', None, cls.getCollisionDetectionPrimitive, cls.getCollisionDetectionPrimitiveCount, cls.addCollisionDetectionPrimitive ),
Member.Point3d( 'pos', (0.0,0.0,0.0), cls.getCMPosition, cls.setCMPosition ),
Member.Vector3d( 'vel', (0.0,0.0,0.0), cls.getCMVelocity, cls.setCMVelocity ),
Member.Quaternion( 'orientation', (0.0,(1.0,0.0,0.0)), cls.getOrientation, cls.setOrientation ),
Member.Vector3d( 'angularVel', (0.0,0.0,0.0), cls.getAngularVelocity, cls.setAngularVelocity ),
Member.Basic( bool, 'locked', False, cls.isLocked, cls.lockBody ),
Member.Basic( float, 'frictionCoeff', 0.8, cls.getFrictionCoefficient, cls.setFrictionCoefficient ),
Member.Basic( float, 'restitutionCoeff', 0.35, cls.getRestitutionCoefficient, cls.setRestitutionCoefficient ),
Member.Basic( tuple, 'groundCoeffs', (0.00001,0.2), getGroundCoeffs, setGroundCoeffs ),
Member.Basic( bool, 'planar', False, cls.isPlanar, cls.setPlanar )
] )
cls = Physics.ArticulatedRigidBody
ArticulatedRigidBody = Proxy.create( cls, parent = RigidBody, loader = Physics.world().addRigidBody, caster = Physics.castToArticulatedRigidBody )
def main():
Proxy().run()
def checkUsername(targetUsername, s, successfulLogin, username):
#global stop_threads
#start monitoring the username
#while not stop_threads:
#while True:
try:
global checkAvailable
global successfullyChanged
#global proxy
usernameURL = 'https://www.instagram.com/web/search/topsearch/?' + urlencode(
{
'context': 'blended',
'query': targetUsername,
'rank_token': '0.395359231827089',
'count': '1'
})
try:
#res = requests.get(usernameURL, timeout=20)
ip = Proxy.returned_proxies()
res = requests.get(usernameURL, proxies=ip, timeout=20)
except requests.exceptions.Timeout:
print('[{0}] is not available'.format(targetUsername))
#proxy=getRandomProxy()
return None
#time.sleep(1)
if res.status_code == 200:
#print(res.text)
try:
json_data = json.loads(res.text)
#print(json_data)
if len(json_data['users']) == 0 and len(
json_data['places']) == 0:
checkAvailable = True
print('[{0}] is available!!!'.format(targetUsername))
#changeUsername(targetUsername)
#print('[{0}] Completed Turbo Killing Thread'.format(targetUsername))
#time.sleep(5)
#system.exit()
availableUsername = targetUsername
if successfulLogin:
#r = s.get("https://www.instagram.com/")
#csrftoken = re.search('(?<="csrf_token":")\w+', r.text).group(0)
#s.cookies["csrftoken"] = csrftoken
#s.headers.update({"X-CSRFToken": csrftoken})
#finder = r.text.find(username)
#if finder != -1:
url_edit = "https://www.instagram.com/accounts/edit/"
#r = s.get("https://www.instagram.com/")
#csrftoken = re.search('(?<="csrf_token":")\w+', r.text).group(0)
#s.cookies["csrftoken"] = csrftoken
#s.headers.update({"X-CSRFToken": csrftoken})
formData = {
'first_name': 'Vnes',
'email': email,
'username': availableUsername,
'phone_number': '',
'biography': '',
'external_url': '',
'chaining_enabled': 'on'
}
# print(availableUsername)
rf = s.post(url_edit, data=formData)
print(rf.text)
with open('Found_Names.txt', 'a') as f:
f.write(targetUsername + '\n')
with open("config.json") as file:
update = json.load(file)
update['username'] = availableUsername
username = availableUsername
with open('config.json', 'w') as f:
json.dump(update, f)
successfullyChanged = True
print('Successfully Changed the Username.')
else:
checkAvailable = False
print("Login error! Connection error!")
else:
print('[{0}] is not available'.format(targetUsername))
except:
print('[{0}] is not available'.format(targetUsername))
#proxy=getRandomProxy()
except:
pass
if menino_burro:
print "\n\nQueridão informe um ID válido\n\n"
else:
titulo = raw_input("Informe o novo Titulo: ")
alterar.titulos = alterar.titulos + " : " + titulo
resp = proxy.AddTitulo(alterar)
if resp == "true":
print "\nTime atualizado com sucesso\n"
else:
print "\nDeu erro\n"
if __name__ == '__main__':
u = user()
proxy = Proxy.ProxyUser()
op = -1
while op!=6:
print "\n##################"
print "Escolha a opção desejada"
print "1 - Adicionar Time"
print "2 - Listar Times"
print "3 - Remover Time"
print "4 - Buscar Time"
print "5 - Adicionar Titulo"
print "6 - Sair"
print "##################\n"
op = int(raw_input("Digite a opção: "))
if op == 1:
u.AddTime()
from Proxy import *
import socket
#socket.setdefaulttimeout(60)
p = Proxy(60, False, 'workingproxy.txt', 'proxies.txt', ['https://www.qaparichay.in'])
p.getProxies()
import time
start_time = time.time()
ghtml = p.getMeData('http://www.spokeo.com/email-search/[email protected]')
import gzip
print ghtml
import StringIO
compressedstream = StringIO.StringIO(ghtml)
f = gzip.GzipFile(fileobj=compressedstream)
html = f.read()
print html
print("--- %s seconds ---" % (time.time() - start_time))
# p.getMeData('https://www.qaparichay.in')
# p.getMeData('https://www.qaparichay.in')
# p.getMeData('https://www.qaparichay.in')
# p.getMeData('https://www.qaparichay.in')
# p.getMeData('https://www.qaparichay.in')
# p.getMeData('http://api.meetup.com/2/member/2?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/3?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/4?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/5?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/6?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/7?key=59194e36d4381f353e1151602c29f')
# p.getMeData('http://api.meetup.com/2/member/8?key=59194e36d4381f353e1151602c29f')
'''
Created on 2009-09-03
@author: beaudoin
'''
import Proxy
import Member
import Physics, Core, wx
cls = Physics.ArticulatedFigure
ArticulatedFigure = Proxy.create(
cls,
loader=Physics.world().addArticulatedFigure,
members=[
Member.Basic(str, 'name', 'UnnamedArticulatedFigure', cls.getName,
cls.setName),
Member.Object('root', None, cls.getRoot, cls.setRoot),
Member.ObjectList('arbs', None, cls.getArticulatedRigidBody,
cls.getArticulatedRigidBodyCount,
cls.addArticulatedRigidBody),
Member.ObjectList('joints', None, cls.getJoint, cls.getJointCount,
cls.addJoint)
])
cls = Core.Character
Character = Proxy.create(cls,
parent=ArticulatedFigure,
loader=wx.GetApp().addCharacter)
"""
Created on 2009-09-02
@author: beaudoin
"""
import Proxy
import Member
import Physics
cls = Physics.SphereCDP
SphereCDP = Proxy.create(
cls,
verbose=False,
caster=Physics.castToSphereCDP,
members=[
Member.Point3d("center", (0.0, 0.0, 0.0), cls.getCenter, cls.setCenter),
Member.Basic(float, "radius", 1.0, cls.getRadius, cls.setRadius),
],
)
cls = Physics.BoxCDP
BoxCDP = Proxy.create(
cls,
verbose=False,
caster=Physics.castToBoxCDP,
members=[
Member.Point3d("point1", (-1.0, -1.0, -1.0), cls.getPoint1, cls.setPoint1),
Member.Point3d("point2", (1.0, 1.0, 1.0), cls.getPoint2, cls.setPoint2),
],
)
