def fill_gen_book_places_for_workshop():
connector = Connector()
conn = connector.connect(secretpassword)
cursor = conn.cursor()
cursor.execute(
"select Reservations.ReservationID, WorkshopID, MaxSpots "
"from DaysOfConf "
"inner join Workshops on Workshops.DayID = DaysOfConf.DayID "
"inner join Reservations on Reservations.DayID = DaysOfConf.DayID")
row = cursor.fetchone()
c = Connector()
cn = c.connect(secretpassword)
while row:
reservationid = row[0]
workshopid = row[1]
maxspots = math.floor(row[2] / 3)
result = (reservationid, workshopid, maxspots)
print("Add Workshop Reservation " + str(result))
c.apply_proc('BookPlacesForWorkshop', result)
row = cursor.fetchone()
conn.close()
cn.close()
def fill_gen_add_payment():
connector = Connector()
conn = connector.connect(secretpassword)
cursor = conn.cursor()
cursor.execute(
"select ReservationID, ToPay, ReservationDate from Reservations")
row = cursor.fetchone()
ratio = [i / 10 for i in range(1, 11)]
c = Connector()
cn = c.connect(secretpassword)
while row:
reservationid = row[0]
topay = row[1]
date = row[2]
money_deposited = math.floor(int(topay) * random.choice(ratio))
(y, m, d) = date.split("-")
begin = dt.date(int(y), int(m), int(d)).toordinal()
book_ord = dt.datetime.fromordinal(begin + random.randint(1, 7))
date_of_payment = "/".join(
(str(book_ord.year), str(book_ord.month), str(book_ord.day)))
result = (reservationid, money_deposited, date_of_payment)
print("Add Payment " + str(result))
c.apply_proc('GeneratorAddPayment', result)
row = cursor.fetchone()
conn.close()
cn.close()
def fill_gen_add_attendees():
connector = Connector()
conn = connector.connect(secretpassword)
cursor = conn.cursor()
cursor.execute(
"select company.clientid, spotsreserved from company "
"inner join clients on clients.clientid = company.clientid "
"inner join reservations on reservations.clientid = clients.clientid")
row = cursor.fetchone()
c = Connector()
cn = c.connect(secretpassword)
while row:
clientid = row[0]
spots_reserved = row[1]
for reservation in range(spots_reserved):
name, surname = getNameSurname()
result = (clientid, name, surname)
print("Add Attendee " + str(result))
c.apply_proc('AddAttendee', result)
row = cursor.fetchone()
conn.close()
cn.close()
def fill_gen_assign_workshop_attendee():
connector = Connector()
conn = connector.connect(secretpassword)
cursor = conn.cursor()
workshop_attendees = []
cursor.execute(
"select distinct Attendees.AttendeeID, WorkshopReservations.WReservationID "
"from Attendees "
"inner join Participation on Participation.AttendeeID = Attendees.AttendeeID "
"inner join Reservations on Reservations.ReservationID = Participation.ReservationID "
"inner join WorkshopReservations on WorkshopReservations.ReservationID = Reservations.ReservationID"
)
row = cursor.fetchone()
while row:
workshop_attendees.append((row[0], row[1]))
row = cursor.fetchone()
filler = Connector()
workshop_attendees_size = len(workshop_attendees)
filler.apply_proc_multi('AssignParticipantToWorkshop', workshop_attendees,
workshop_attendees_size)
conn.close()
def addConnectors(self):
for i in range(self.mapBorder, self.width - self.mapBorder):
for j in range(self.mapBorder, self.height - self.mapBorder):
for k in range(-1, 2, 2):
if self.tiles[i - 1][j] != self.tiles[
i + 1][j] and self.tiles[i][j] == 0 and self.tiles[
i - 1][j] != 0 and self.tiles[
i + 1][j] != 0 and self.tiles[
i - 1][j] != 1000 and self.tiles[
i + 1][j] != 1000:
self.tiles[i][j] = 1000
self.connectors.append(
Connector(
len(self.connectors) + 1, i, j,
self.tiles[i - 1][j], self.tiles[i + 1][j], 0))
if self.tiles[i][j - 1] != self.tiles[i][
j + 1] and self.tiles[i][j] == 0 and self.tiles[i][
j - 1] != 0 and self.tiles[i][
j + 1] != 0 and self.tiles[i][
j - 1] != 1000 and self.tiles[i][
j + 1] != 1000:
self.tiles[i][j] = 1000
self.connectors.append(
Connector(
len(self.connectors) + 1, i, j,
self.tiles[i][j + 1], self.tiles[i][j - 1], 0))
def find_point(self, t, method='arc_connect'):
assert 0 <= t <= 1, 't must be between 0 and 1'
weights_model_new = getattr(Connector(self.weights_model1, self.weights_model2_permuted), method)(t=t)[1]
B = self.get_b(self.model1, self.model2)
B = getattr(Connector(B[:1], B[1:]), method)(t=t)[1]
m = self.get_model_from_weights(weights_model_new, B[0], self.architecture)
m.cuda();
return m
def fill_gen_assign_attendee():
connector = Connector()
conn = connector.connect(secretpassword)
cursor = conn.cursor()
individual_participation = []
cursor.execute(
"select distinct Attendees.AttendeeID, Reservations.ReservationID "
"from Attendees "
"inner join Clients on Attendees.ClientID = Clients.ClientID "
"inner join Reservations on Reservations.ClientID = Clients.ClientID "
"inner join Individual on Individual.ClientID = Clients.ClientID")
row = cursor.fetchone()
while row:
individual_participation.append((row[0], row[1]))
row = cursor.fetchone()
company_participation = []
cursor.execute(
"select distinct Attendees.AttendeeID, Reservations.ReservationID "
"from Attendees "
"inner join Clients on Attendees.ClientID = Clients.ClientID "
"inner join Reservations on Reservations.ClientID = Clients.ClientID "
"inner join Company on Company.ClientID = Clients.ClientID")
row = cursor.fetchone()
while row:
company_participation.append((row[0], row[1]))
row = cursor.fetchone()
# Two list of (AttendeeID, ReservationID) to apply
# The following lines may cause declination of IDE control xD
# print(individual_participation)
# print(len(individual_participation))
# print(company_participation)
# print(len(company_participation))
# Those insertions causes error -> try block
filler = Connector()
individual_size = len(individual_participation)
filler.apply_proc_multi('AssignAttendee', individual_participation,
individual_size)
company_size = len(company_participation)
filler.apply_proc_multi('AssignAttendee', company_participation,
company_size)
conn.close()
def find_point(self, t=0.5, method='arc_connect'):
layer = int(t // 1)
t = t - layer
if layer >= self.depth - 1:
layer = self.depth - 2
t = 1
assert layer < self.depth, 'the network is shot for this t value'
W10 = deepcopy(self.weights_adjusted[layer])
W20 = deepcopy(self.weights_model2[0::2][layer])
B10 = deepcopy(self.weights_model1[1::2][layer])
B20 = deepcopy(self.weights_model2[1::2][layer])
W11 = deepcopy(self.weights_model1[0::2][layer + 1])
# W11b2 = deepcopy(self.weights_adjusted[layer + 1])
W1_butterflyed = self.butterfly_weights(W10, B10)
W2_butterflyed = self.butterfly_weights(W20, B20)
GO = self.solve_optimal_transport_problem(W1_butterflyed,
W2_butterflyed)
indices = np.argmax(GO, axis=-1)
W2_butterflyed_permuted = W2_butterflyed[indices]
W20, B20 = self.unbutterfly_weights(W2_butterflyed_permuted, W20.shape)
Wn0 = getattr(Connector(W10, W20), method)(t=t)[1]
Bn0 = getattr(Connector(B10, B20), method)(t=t)[1]
# beg new
weights_model_till_n1 = self.weights_model2[:2 * layer] + [
Wn0, Bn0
] + self.weights_model1[2 * layer + 2:]
m_till_n1 = get_model_from_weights(weights_model_till_n1,
self.architecture)
features_new = self.get_funcs(m_till_n1,
self.loader,
layer + 1,
padding=self.padding,
kernel_size=self.kernel_size,
stride=self.stride)
Wn1 = self.adjust_weights(
self.funcs1[layer],
features_new,
W11,
)
# end new
weights_model_t = self.weights_model2[:2 * layer] + [
Wn0, Bn0, Wn1
] + self.weights_model1[2 * layer + 3:]
m = get_model_from_weights(weights_model_t, self.architecture)
return m
def get_connect_str(self, connobj):
if isinstance(connobj, dict):
self._connobj = Connector(**connobj)
self._connobj._engine = self
return self._connobj.connect_str
elif isinstance(connobj, Connector):
self._connobj._engine = self
return connobj.connect_str
elif isinstance(connobj, basestring):
self._connobj = Connector(connect_str=connobj)
self._connobj._engine = self
return connobj
raise Exception('Error %s\'connector type: %s(%s)' %
(self.__class__.__name__, connobj, type(connobj)))
def post(self):
# Region Set Up
#create resultService object
_resultsService = ResultsService()
#load queries
q = Queries()
# create connection to postgres database
_connector = Connector()
conn = _connector.connect(1)
# create cursor
cur = conn.cursor()
#define query parameters
_failID = self.get_argument("_failureId")
# endregion
# Region main block
cur.execute(q._email_failure, (_failID, ))
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
self.render("emailMonitor.html", results=_result)
cur.close()
conn.close
async def check(self, proxy: ProxyModel):
logger.debug('Start Verify Proxy: %s' % proxy)
proxy.usable = False
judge = self.https_judge if proxy.protocol == 'https' else self.http_judge
content = None
conn = Connector(proxy.ip, proxy.port)
negotiator = NGTRS[proxy.protocol.upper()](conn)
try:
await conn.connect()
await negotiator.negotiate(judge)
headers, content, hdrs = await _send_test_request(
self._method, conn, negotiator, judge)
content = _decompress_content(headers, content)
judge.parse_response(proxy, content, hdrs)
except ProxyError:
pass
except JSONDecodeError:
# Config.logger.error('Json decode error when using %s' % proxy)
logger.debug(content)
except Exception as e:
logger.error('Error: %s, type: %s' % (proxy, type(e)),
exc_info=True)
finally:
conn.close()
proxy.verified_at = datetime.datetime.now()
self.finished += 1
logger.debug('Finished Proxy: %s' % (proxy))
return proxy
def connect_butterflies(W10,
W20,
B10,
B20,
W11,
W11b2,
t=0.5,
method='arc_connect'):
Wn0 = getattr(Connector(W10, W20), method)(t=t)[1]
Bn0 = getattr(Connector(B10, B20), method)(t=t)[1]
Wn1 = getattr(
Connector(PointFinderStepWiseButterflyConvWBias.transpose(W11),
PointFinderStepWiseButterflyConvWBias.transpose(W11b2)),
method)(t=t)[1]
Wn1 = PointFinderStepWiseButterflyConvWBias.transpose(Wn1)
return Wn0, Bn0, Wn1
def runConnectorRefused():
confi['configs'][0]['parameters'][0]['state'] = 'BEGIN'
confi['configs'][0]['parameters'][0]['action'] = 'BEGIN'
confi['configs'][0]['parameters'][0]['flags'] = 'RPA'
con = Connector(confi, debug=3)
con.runbg()
return con
def load_from_connector(self, name, method_name):
'''
Load given connector (name) and apply the given method on it.
Supported method: get_accounts and get_history.
Expected fields:
* login
* password
* website (optional)
'''
params_connector = {
'login': self.login,
'password': self.password,
}
if self.website is not None:
params_connector['website'] = self.website
try:
connector = Connector(name, params_connector)
results = {}
callback = getattr(connector, method_name)
results[name] = callback()
except ModuleLoadError:
raise Exception("Could not load module: %s" % name)
except BrowserIncorrectPassword:
raise Exception("Wrong credentials")
except Exception as e:
EnsurePrint(unicode(e))
raise Exception("Something went wrong (weboob modules should "
"probably be updated)")
return results
def test_connector_instance_creation_without_connection_to_database_wrong(
self):
with self.assertRaises(connector.DatabaseConnectionError) as raised_exception:
inst = Connector("sad", 'sad', 'someesindex', 'sda')
self.assertEqual(
raised_exception.exception.args[0],
'Connection to databes has failed')
def add_insta(received):
username = received['username']
password = received['password']
user = received['user']
conn = Connector()
result = conn.add_insta(username, password, user)
return result['message']
def post(self):
# Region Set Up
_resultsService = ResultsService()
_q = Queries()
_connector = Connector()
conn = _connector.connect(2)
cur = conn.cursor()
# endregion
# Region Main Block
cur.execute(_q._get_all_users)
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
for item in _result:
_rID = str(item[3])
_id = self.get_arguments("_checkbox")
if _rID in _id:
print("Deleting " + str(item[0]))
cur.execute(_q._delete_user, (item[3], ))
conn.commit()
cur.close()
conn.close()
self.redirect("/users")
def main():
global connector
global detector
# Get port argument
if len(sys.argv) < 2:
raise Exception("Missing port argument")
port = None
try:
port = int(sys.argv[1])
if type(port) is not int or port < 1 or port > 65535:
raise Exception()
except:
raise TypeError(
"Port argument must be an integer between 1 and 65535 (inclusive)")
# Connect to server
connector = Connector(port, message_received)
# Start Detector
detector = Detector(new_detections)
detector.start_detections()
# Notify server that the client has started
connector.send_message(Message(100, "{}"))
# Keep the program alive
detector._thread.join()
def post(self):
# Region Set Up
#create resultService object
_resultsService = ResultsService()
#load queries
q = Queries()
# create connection to postgres database
_connector = Connector()
conn = _connector.connect(2)
# create cursor
cur = conn.cursor()
#define query parameters
_firstname = self.get_argument("_firstname_field")
_lastname = self.get_argument("_lastname_field")
_timenow = datetime.datetime.now()
# endregion
# Region main block
_query = q._get_all_users
cur.execute(_query)
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
_query = q._create_new_user
cur.execute(_query, (_firstname, _lastname, _timenow))
conn.commit()
cur.close()
conn.close
self.redirect("/users")
def __init__(self, slave = False, protocol = None, address = None, port = None, target_name = None):
self.config = Configurator()
self.is_connected = False
self.is_slave = slave
self.parameters = None
self.datastream_queue = None
self.datastream_poller = None
self.datastream_collector = None
self.signal_structure = None
# Sets basic configurations
if protocol:
self.config.setAttr('protocol', protocol)
if address:
self.config.setAttr('address', address)
if port:
self.config.setAttr('port', port)
if target_name:
self.config.setAttr('target_name', target_name)
# Initializes connection
self.connection = Connector(self.config)
def schedule_posting(received):
user = received['user']
img = received['img']
binary_image = received['binary_image']
subtitle = received['subtitle']
location = received['location']
instagram = received['instagram']
date = received['date']
date_image = f'{datetime.now().year}-' + f'{datetime.now().month}-' + f'{datetime.now().day}'
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
img_path = os.path.join(BASE_DIR, f"uploads/{date_image}-{user}-{img}")
if date < datetime.now():
return 'Horario invalido'
conn = Connector()
result = conn.add_schedule(img_path, subtitle, location, instagram, date,
user)
if result['status'] != None:
# Salvando a imagem na pasta upload com o nome padrão : yyyy-mm-dd-email-name.jpeg
with open((img_path), 'wb') as f:
f.write(binary_image)
f.close()
scheduler()
time.sleep(1)
return 'success'
# return send_api(received, img_path)
return result['message']
def __new__(self, shape):
if shape == "Chart":
return Chart()
if shape == "Image":
return Image()
if shape == "Table":
return Table()
if shape == "BarCode":
return BarCode()
if shape == "Text":
return Text()
if shape == "Rounded":
return Rounded()
if shape == "Box":
return Box()
if shape == "Connector":
return Connector()
if shape == "Curve":
return Curve()
if shape == "Line":
return Line()
if shape == "Arc":
return Arc()
return None
def find_point(self, t=0.5, method='lin_connect'):
layer = int(t // 1)
t = t - layer
if layer >= self.depth - 1:
layer = self.depth - 2
t = 1
assert layer < self.depth, 'the network is shot for this t value'
W11 = self.weights_model1[layer + 1]
W20 = self.weights_model2[layer]
W10 = self.weights_adjusted[layer]
W11b2 = self.weights_adjusted[layer + 1]
weights1 = self.butterfly_weights(W10, W11)
weights2 = self.butterfly_weights(W20, W11b2)
GO = self.solve_optimal_transport_problem(weights1, weights2)
# TODO: make an assertion that there are only zero and ones in GO
indices = np.argmax(GO, axis=-1)
weights2_permuted = weights2[indices]
weights_model_new = getattr(Connector(weights1, weights2_permuted), method)(t=t)[1]
Wn0, Wn1 = self.unbutterfly_weights(weights_model_new, len(W10.T))
weights_model_t = self.weights_model2[:layer] + [Wn0, Wn1] + self.weights_model1[layer + 2:]
m = get_model_from_weights(weights_model_t, self.architecture)
m.cuda();
return m
def __init__(self, client, peer_id, addr, socket=None, info_hash=None):
self._client = client
self._socket = socket
self._info_hash = info_hash
self._peer_id = peer_id
self._addr = addr
self._choked = True
self._interested = False
self._peer_choked = True
self._peer_interested = False
if len(peer_id) != 20:
raise ValueError("Peer id must be 20 bytes long")
if socket is None:
if info_hash is None or len(info_hash) != 20:
raise ValueError("Info hash must be a 20 byte value")
self._translator = None
self._socketreaderwriter = None
Connector().connect(addr, self)
self._state = self._States.Awaiting_Connection
else:
self._setup_handshake_translator()
self._state = self._States.Awaiting_Handshake
def generate_connections(self):
try:
self.atom_labels, self.bonds
except AttributeError:
raise Exception("Simulation has not been assigned atom types and bonds yet")
connect = Connector()
self.bond_types = connect.find_bond_types(self.atom_labels, self.bonds)
self.bond_labels = connect.bond_labels(
self.atom_labels, self.bonds, self.bond_types
)
self.bond_graph = self.generate_bond_graph(self.bonds)
self.angles = connect.angles(self.bonds, self.bond_graph)
self.angle_types = connect.find_angle_types(self.atom_labels, self.angles)
self.angle_labels = connect.angle_labels(
self.atom_labels, self.angles, self.angle_types
)
self.dihedrals = connect.dihedrals(self.bonds, self.bond_graph)
self.dihedral_types = connect.find_dihedral_types(
self.atom_labels, self.dihedrals
)
self.dihedral_labels = connect.dihedral_labels(
self.atom_labels, self.dihedrals, self.dihedral_types
)
self.impropers = connect.impropers(self.bonds, self.bond_graph)
self.improper_types = connect.find_improper_types(
self.atom_labels, self.impropers
)
self.improper_labels = connect.improper_labels(
self.atom_labels, self.impropers, self.improper_types
)
def __init__(self):
rospy.init_node('Gateway', log_level=rospy.DEBUG)
server_config_file = rospy.get_param("~server_config_file")
self.config = Config(server_config_file)
self.pf = ProtocolFactory(self.config)
self.run_id = rospy.get_param("run_id")
print("runid = ", self.run_id)
self.node_list = rosnode.get_node_names()
self.timer = Timer()
self.monitor = Monitor(self.node_list, self.timer)
self._server_request = {} # stores server_request
self._event_bus = Queue()
self._heartbeat_timeout_job = None
self._tele_report_job = None
self._report_car_job = None
self._report_task_job = None
self._service = DrivingTaskService(self._event_bus)
self.__client = Connector(self._event_bus, self.config.host,
self.config.port)
self._handler_map = {}
self._event_handler_map = {}
self._add_command_handler()
self._add_event_handler()
self._web_server = WebServer(self.monitor, self._service, self.config)
self._tele_control_service = TeleControlService()
def setUp(self):
c = omero.client(
pmap=['--Ice.Config=' + (os.environ.get("ICE_CONFIG"))])
try:
self.root_password = c.ic.getProperties().getProperty(
'omero.rootpass')
omero_host = c.ic.getProperties().getProperty('omero.host')
finally:
c.__del__()
blitz = Server.find(host=omero_host)
if blitz is None:
Server.reset()
for s in settings.SERVER_LIST:
server = (len(s) > 2) and unicode(s[2]) or None
Server(host=unicode(s[0]), port=int(s[1]), server=server)
Server.freeze()
blitz = Server.find(server=omero_host)
if len(blitz):
self.server_id = blitz[0].id
connector = Connector(self.server_id, True)
self.rootconn = connector.create_connection(
'TEST.webadmin', 'root', self.root_password)
if self.rootconn is None or not self.rootconn.isConnected(
) or not self.rootconn.keepAlive():
raise exceptions.Exception("Cannot connect")
else:
raise exceptions.Exception("'%s' is not on omero.web.server_list" %
omero_host)
def poolLoadTSV((tsv, ks_minor, units, db, ksm_filter, ksm_id, rename, host,
port, is_json)):
"""
This function is used by multiprocess.Pool to populate framespace with a new dataframe.
"""
try:
# register vectors and get the dataframe object for insert
conn = Connector(db, host=host, port=port)
if is_json:
df_id = conn.registerDataFrame(tsv,
ks_minor,
units,
is_json=is_json)
else:
df_id = conn.registerDataFrame(
getDataFrame(tsv,
ksminor_id=ksm_id,
ksminor_filter=ksm_filter,
rename=rename), ks_minor, units)
except Exception, e:
traceback.print_exc(file=sys.stdout)
print "Error processing"
print str(e)
return (-1, tsv)
def test_loginFromForm(self):
params = {
'username': '******',
'password': self.root_password,
'server':self.server_id,
'ssl':'on'
}
request = fakeRequest(method="post", params=params)
server_id = request.REQUEST.get('server')
form = LoginForm(data=request.REQUEST.copy())
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
server_id = form.cleaned_data['server']
is_secure = toBoolean(form.cleaned_data['ssl'])
connector = Connector(server_id, is_secure)
conn = connector.create_connection('OMERO.web', username, password)
if conn is None:
self.fail('Cannot connect')
conn.seppuku()
if conn.isConnected() and conn.keepAlive():
self.fail('Connection was not closed')
else:
errors = form.errors.as_text()
self.fail(errors)
def mode(self, mode = 'hour', color = [0, 0, 0]):
"""
Update Dotti to the given mode
Args:
mode (str): either 'hour' or 'color'
color (arr[int, int, int]): R,G,B color to use
"""
conn = Connector(self.mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
try:
if mode == 'color':
conn.writeCharacteristic('0x2a', '0601'+self.__twoDigitHex(int(color[0]))+self.__twoDigitHex(int(color[1]))+self.__twoDigitHex(int(color[2]))+'00')
elif mode == 'hour':
conn.writeCharacteristic('0x2a', '040502')
except Exception as error:
logger.error(str(error))
conn.disconnect()
return
