def setup(hass, config):
"""Set up the Goalfeed component."""
conf = config[DOMAIN]
username = conf.get(CONF_USERNAME)
password = conf.get(CONF_PASSWORD)
def goal_handler(data):
"""Handle goal events."""
goal = json.loads(json.loads(data))
hass.bus.fire("goal", event_data=goal)
def connect_handler(data):
"""Handle connection."""
post_data = {
"username": username,
"password": password,
"connection_info": data,
}
resp = requests.post(GOALFEED_AUTH_ENDPOINT, post_data,
timeout=30).json()
channel = pusher.subscribe("private-goals", resp["auth"])
channel.bind("goal", goal_handler)
pusher = pysher.Pusher(GOALFEED_APP_ID,
secure=False,
port=8080,
custom_host=GOALFEED_HOST)
pusher.connection.bind("pusher:connection_established", connect_handler)
pusher.connect()
return True
def __init__(self, api_key):
self.__api_key = api_key
self.__job_channel_auth = None
self.__job_channel_name = 'presence-jobs.{}'
self.__job_channel = None
self.__connected = False
self.__wshost = 'socket.elytica.com'
self.__pusher = pysher.Pusher(custom_host=self.__wshost, key='elytica_service',\
secret=self.__api_key, auto_sub=True, ping_interval=30)
self.__headers = {"Authorization": "Bearer " + api_key}
self.__scheme = "https://"
self.__basename = "service.elytica.com/api"
self.__api_user = "******"
self.__channel_auth = "service.elytica.com/broadcasting/auth"
self.__api_projects = "/projects"
self.__api_applications = "/applications"
self.__api_projects_createjob = "/projects/{project}/createjob"
self.__api_projects_getjobs = "/projects/{project}/getjobs"
self.__api_projects_files = "/projects/{project}/files"
self.__api_update = "/update/{job}"
self.__api_projects_upload = "/projects/{project}/upload"
self.__api_projects_assignfile = "/projects/{project}/assignfile/{job}"
self.__api_projects_outputfiles = "/projects/{project}/outputfiles/{job}"
self.__api_projects_download = "/projects/{project}/download/{file}"
self.__projects = []
self.__jobs = []
self.__applications = []
self.__inputfiles = []
self.__outputfiles = []
self.__selected_project = None
self.__selected_application = None
self.__selected_job = None
def initPusher(self):
self.pusher = Pusher(app_id=os.getenv('PUSHER_APP_ID', None), key=os.getenv('PUSHER_APP_KEY', None), secret=os.getenv('PUSHER_APP_SECRET', None), cluster=os.getenv('PUSHER_APP_CLUSTER', None))
# инициализирую новый Pysher клиент передавая APP_KEY
self.clientPusher = pysher.Pusher(os.getenv('PUSHER_APP_KEY', None), os.getenv('PUSHER_APP_CLUSTER', None))
# Связываюсь с соеденением событием и передаю connectHandler в качестве обратного вызова
self.clientPusher.connection.bind('pusher:connection_established', self.connectHandler)
self.clientPusher.connect()
class Trades:
pusher = pysher.Pusher("de504dc5763aeef9ff52", daemon=False)
def __init__(self):
self.pusher.connection.bind('pusher:connection_established',
self.listen)
self.pusher.connect()
def listen(self, data):
channel = self.pusher.subscribe('live_trades_ltcusd')
channel.bind('trade', self.get)
def get(self, *args):
jsonify = args[0].split("'")[0]
data = json.loads(jsonify)
self.push_to_DB(data)
def push_to_DB(self, data):
unixtimestamp = int(data["timestamp"])
price = data['price_str']
amount = data['amount']
sel_order = data['type']
buy_id = data['buy_order_id']
sell_id = data['sell_order_id']
cur.execute(
"INSERT INTO TRADES (UNIXTIMESTAMP,PRICE,AMOUNT,SELL_ORDER,BUY_ID,SELL_ID) \
VALUES (%s, %s, %s, %s, %s, %s)",
(unixtimestamp, price, amount, sel_order, buy_id, sell_id))
conn.commit()
def __init__(self, *args, **kwargs):
self.key = "de504dc5763aeef9ff52"
self.channels = {}
self.messages = {
"live_trades": ["trade"],
"order_book": ["data"],
"diff_order_book": ["data"],
"live_orders": ["order_created", "order_changed", "order_deleted"]
}
for channel in self.messages.keys():
self.channels[channel] = []
for pair in ["btceur", "eurusd"]:
self.channels[channel + "_" + pair] = []
self.orderbook = {
"btc": {
"eur": None,
"usd": None
},
"eur": {
"usd": None
}
}
self.lastprice = self.orderbook
self.openorders = self.orderbook
for base in self.openorders.keys():
for quote in self.openorders[base].keys():
self.openorders[base][quote] = {"price": {}, "id": {}}
self.pusher = pysher.Pusher(self.key)
self.pusher.connect()
def __init__(self):
if os.path.exists("./data.json"):
with open('data.json', 'r') as openfile:
json_object = json.load(openfile)
pusherID = json_object["pusherAppID"]
pusherKey = json_object["pusherKey"]
pusherSecret = json_object["pusherSecret"]
pusherCluster = json_object["pusherCluster"]
#start a logging handler so we can see the raw communication data
root = logging.getLogger()
root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
root.addHandler(ch)
#end logging
self.pusher_server = pysher.Pusher(key=pusherKey,
cluster=pusherCluster)
self.pusher_server.connection.bind('pusher:connection_established',
self.__connect_handler)
self.pusher_server.connect()
try:
self.pusher_client = pusher.Pusher(app_id=pusherID,
key=pusherKey,
secret=pusherSecret,
cluster=pusherCluster)
except ValueError as err:
print(
"Pusher Connection Failed. Check Your Credentials!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
)
while True:
# Do other things in the meantime here...
time.sleep(1)
def __init__(self, pair_name):
self.pair_name = pair_name
self.pusher = pysher.Pusher(self.WEX_PUSHER_KEY,
custom_host='ws-{}.pusher.com'.format(
self.WEX_PUSHER_CLUSTER),
log_level=logging.WARNING)
self._logger = logging.getLogger(__name__)
def main():
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
# output = logging.StreamHandler(sys.stdout)
output = logging.FileHandler('galileu.log')
formatter = logging.Formatter('%(message)s\n-')
output.setFormatter(formatter)
logger.addHandler(output)
def func(last_data):
with open('lattest.csv', 'a', newline='') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
data_dict = json.loads(last_data)
spamwriter.writerow([data_dict['timestamp'],data_dict['price'],data_dict['amount']])
def connect_handler(data):
channel = pusher.subscribe('live_trades')
channel.bind('trade', func)
while True:
appkey = 'de504dc5763aeef9ff52'
logger.warning('\nConnecting at {}.'.format(datetime.datetime.utcfromtimestamp(time.time())))
pusher = pysher.Pusher(appkey)
pusher.connection.bind('pusher:connection_established', connect_handler)
pusher.connect()
while True:
time.time()
def __init__(self, appKey, cluster, secret, callback, logging=False):
if logging:
root = logging.getLogger()
root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
root.addHandler(ch)
self.pusher = pysher.Pusher(appKey, cluster=cluster, secret=secret)
self.callback = callback
def __init__(
self,
api_token: str,
email=None,
password=None,
existing_session=None,
analysis_path=None,
twofactor_prompt: Callable = None,
subscribe: bool = False,
config: ConfigParser = ConfigParser(),
):
""" Construct a connection with the specified API key """
# Save configuration info
self.config = config
# Save the API key
self.api_token: str = api_token
# Save authentication information, if we were given any
self.email: str = email
self.password: str = password
# API result cache
self._cache: Dict[str, Any] = {}
self.cache_timeout: float = 60
# Callback to get two factor prompt
self.twofactor_prompt = twofactor_prompt
# Ongoing session for standard authentication
self.session = requests.Session()
self.session.cookies.update({"hackthebox_session": existing_session})
# List of tracked machines
self._machines: Dict[int, Machine] = {}
# Path where machine analysis is kept
self.analysis_path = analysis_path
# Subscribe the asynchronous messages via Pusher (WebSockets)
if subscribe:
# If you don't subscribe, you don't need pysher
import pysher
self.subcribed: bool = True
self.subscriber_lock: threading.Lock = threading.RLock()
self.subscribers: Dict[str, Callable] = {}
self.pusher = pysher.Pusher("97608bf7532e6f0fe898", cluster="eu")
def _on_connect(data):
channel = self.pusher.subscribe("notifications-channel")
channel.bind("display-notification", self._on_notification)
self.pusher.connection.bind("pusher:connection_established",
_on_connect)
self.pusher.connect()
def initiate_pusher(self):
self.pusher = Pusher(app_id=os.getenv('PUSHER_APP_ID', None),
key=os.getenv('PUSHER_APP_KEY', None),
secret=os.getenv('PUSHER_APP_SECRET', None),
cluster=os.getenv('PUSHER_APP_CLUSTER', None))
self.client_pusher = pysher.Pusher(key=os.getenv('PUSHER_APP_KEY', None),
cluster=os.getenv('PUSHER_APP_CLUSTER', None))
self.client_pusher.connection.bind('pusher:connection_established', self.connection_manager)
self.client_pusher.connect()
def initPusher(self):
self.pusher = Pusher(app_id="PUSHER_APP_ID",
key="PUSHER_KEY",
secret="PUSHER_SECRET",
cluster="PUSHER_CLUSTER")
self.clientPusher = pysher.Pusher("PUSHER_KEY", "PUSHER_CLUSTER")
self.clientPusher.connection.bind('pusher:connection_established',
self.connectHandler)
self.clientPusher.connect()
def start_engine(self):
self.pusher = Pusher(app_id=self.PUSHER_APP_ID,
key=self.PUSHER_APP_KEY,
secret=self.PUSHER_APP_SECRET,
cluster=self.PUSHER_APP_CLUSTER)
self.clientPusher = pysher.Pusher(self.PUSHER_APP_KEY,
self.PUSHER_APP_CLUSTER)
self.clientPusher.connection.bind('pusher:connection_established',
self.connectHandler)
self.clientPusher.connect()
def initPusher(self):
self.pusher = Pusher(app_id=os.getenv("PUSHER_APP_ID"),
key=os.getenv("PUSHER_APP_KEY"),
secret=os.getenv("PUSHER_APP_SECRET"),
cluster=os.getenv("PUSHER_APP_CLUSTER"))
self.clientPusher = pysher.Pusher(os.getenv("PUSHER_APP_KEY"),
os.getenv("PUSHER_APP_CLUSTER"))
self.clientPusher.connection.bind("pusher:connection_established",
self.connectHandler)
self.clientPusher.connect()
def pusher_client():
return pysher.Pusher(pInfo["key"],
cluster=pInfo["cluster"],
secure=False,
secret=pInfo["secret"],
user_data={"user_id": device_token},
daemon=True,
port=pInfo["port"],
reconnect_interval=10,
custom_host=pInfo["host"],
auto_sub=False)
def main():
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
# output = logging.StreamHandler(sys.stdout)
output = logging.FileHandler('galileu.log')
formatter = logging.Formatter('%(message)s\n-')
output.setFormatter(formatter)
logger.addHandler(output)
ts_first_error = 0
ts_last_error = 0
def func(last_data):
with open('lattest.csv', 'a', newline='') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
data_dict = json.loads(last_data)
spamwriter.writerow([data_dict['timestamp'],data_dict['price'],data_dict['amount']])
def connect_handler(data):
channel = pusher.subscribe('live_trades')
channel.bind('trade', func)
while True:
try:
appkey = 'de504dc5763aeef9ff52'
logger.warning('\nConnecting at {}.'.format(datetime.datetime.utcfromtimestamp(time.time())))
pusher = pysher.Pusher(appkey)
pusher.connection.bind('pusher:connection_established', connect_handler)
pusher.connect()
if ts_first_error != 0:
ts_connection = time.time()
time_off = ts_connection - ts_first_error
logger.warning('The connection was lost for about {} seconds.'.format(time_off))
while True:
time.sleep(1)
except:
ts_error = time.time()
logger.exception('Something wrong happened at {}, {}.'.format(ts_error,datetime.datetime.utcfromtimestamp(ts_error)))
# There are two ways the code can go through this statement.
# First way. Time since last error occurred is too small. If that's the case, pusher may be down and
# we need to chill a bit before trying to reconnect.
if (ts_error - ts_last_error)<1:
time.sleep(1)
# Second way. Time since last error occurred is not that small. If that's the case, pusher may not be
# the reason for the error. Rather, the problem may be due to some error elsewhere, so we will not
# overload the server by trying to reconnect straight away.
else:
ts_first_error = ts_error
with open('lattest.csv', 'a', newline='') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
spamwriter.writerow(['BREAK at {}, {}.'.format(ts_first_error,datetime.datetime.utcfromtimestamp(time.time()))])
ts_last_error = ts_error
def __init__(self, currency, code):
super().__init__(currency)
self.code = code
self.update_rate = 0.0001
self.isWebsocket = True
self.pusher = pysher.Pusher("de504dc5763aeef9ff52",
log_level=logging.ERROR)
self.pusher.connection.bind('pusher:connection_established',
self.connect_handler)
self.pusher.connect()
self.depth_data = {'asks': [], 'bids': []}
self.depth_update_time = time.time()
def initPusher(self):
print(os.getenv('PUSHER_APP_ID', None))
self.pusher = Pusher(app_id=os.getenv('PUSHER_APP_ID', None),
key=os.getenv('PUSHER_APP_KEY', None),
secret=os.getenv('PUSHER_APP_SECRET', None),
cluster=os.getenv('PUSHER_APP_CLUSTER', None))
self.clientPusher = pysher.Pusher(
os.getenv('PUSHER_APP_KEY', None),
os.getenv('PUSHER_APP_CLUSTER', None))
self.clientPusher.connection.bind('pusher:connection_established',
self.connectHandler)
self.clientPusher.connect()
def start(self):
"""
Extension of Pusher.connect() method, which registers all callbacks with
the relevant channels, before initializing a connection.
:return:
"""
super(BitstampWSS, self).start()
self.pusher = pysher.Pusher(self.addr, **self.__pusher_options)
self.pusher.connection.bind('pusher:connection_established',
self._register_bindings)
self.pusher.connect()
def initPusher(self):
self.pusher = Pusher(app_id=settings['PUSHER_APP_ID'],
key=settings['PUSHER_APP_KEY'],
secret=settings['PUSHER_APP_SECRET'],
cluster=settings['PUSHER_APP_CLUSTER'])
self.clientPusher = pysher.Pusher(settings['PUSHER_APP_KEY'],
settings['PUSHER_APP_CLUSTER'])
self.clientPusher.connection.bind('pusher:connection_established',
self.connectHandler)
self.clientPusher.connect()
# Connection established change screens
self.change_screen("chat_screen")
def __init__(self, apiID=None, apiKey=None, apiSecret=None):
self.proxydict = None
self.client_id = apiID
self.api_key = apiKey
self.api_secret = apiSecret
self.logger = logging.getLogger('root')
self.pusher = pysher.Pusher("de504dc5763aeef9ff52")
self.pusher.connection.bind('pusher:connection_established',
self.connect_handler)
self.pusher.connect()
self.depth_data = None
self.update_time = time.time()
#wait for data
self._wait_for_data()
def __init__(self):
'''Initialize HackTheBux pusher.com API instance.'''
warnings.filterwarnings('ignore', category=UserWarning, module='bs4')
self.pusher = pysher.Pusher(PUSHER_APP_ID, PUSHER_APP_CLUSTER)
self.pusher.connection.bind('pusher:connection_established', self.connect_handler)
self.pusher.connect()
self.channels = {
'notifications-channel': None,
'shoutbox-channel' : None,
'infobox-channel' : None,
'VPN-us-free-1' : None,
'VPN-eu-free-1' : None,
'owns-channel' : None,
}
self.events = []
def main():
# Read room id
roomId = -1
try:
f = open('./room_id.conf', 'r')
except FileNotFoundError as e:
roomId = 8126
else:
roomId = int(f.readLine().strip())
f.close()
#Establish pusher connection
pusher = pysher.Pusher(appkey)
def connectionHandler(data):
channel = pusher.subscribe(channelName)
channel.bind(eventName, eventHandler)
pusher.connection.bind('pusher:connection_established', connectionHandler)
pusher.connect()
# Listen for incoming messages from the board
while True:
# This should probably just be removed. It's trash
if(not testMode):
#Receives the data from the User
data = raw_input("Enter the led command to be sent: ")
data_list = list(data)
for i in data_list:
try:
#Sends to the Slaves
writeNumber(ord(i))
time.sleep(.1)
except Exception as e:
print(e)
try:
writeNumber(0x0A)
except Exception as e:
print(e)
class Orders(Trades):
pusher = pysher.Pusher("de504dc5763aeef9ff52", daemon=False)
def listen(self, data):
channel = self.pusher.subscribe('live_orders_ltcusd')
channel.bind('order_created', self.get)
def push_to_DB(self, data):
unixtimestamp = int(data["datetime"])
price = data["price"]
amount = data["amount"]
sel_order = data["order_type"]
order_id = data['id']
cur.execute(
"INSERT INTO ORDERS (ORDER_ID,UNIXTIMESTAMP,PRICE,AMOUNT,SELL_ORDER) \
VALUES (%s, %s, %s, %s, %s)",
(order_id, unixtimestamp, price, amount, sel_order))
conn.commit()
def __init__(self, streamer, config):
self._config = config
self._deviceName = self._config.getstr("DEFAULT", "devicename")
self._zooId = self._config.getstr("DEFAULT", "zooid")
self._deviceId = self._config.getstr("DEFAULT", "deviceid")
self._pusherKey = self._config.getstr("PUSHER", "key")
self._pusherSecret = self._config.getstr("PUSHER", "secret")
self._pusherHost = self._config.getstr("PUSHER", "host")
self._logfile = open("./true360/logs/pusher-log.txt", "w")
self._log_handler(self._logfile)
self._pusher = pysher.Pusher(key=self._pusherKey,
secret=self._pusherSecret,
custom_host=self._pusherHost,
name="connection-thread")
self._channel = None
self._connection = None
self._connected = False
self._registration_channel = "private-%s" % self._deviceId
self._device_channel = None
self._streamer = streamer
index = 0.00000001
def channel_callback(data):
global index
print("Channel Callback: %s" % data)
print("time %.2fs" % (index / 100.0))
index = 0
def connect_handler(data):
print('connceted!')
channel = pusher.subscribe("live_orders_bchusd")
print(channel)
channel.bind('order_created', channel_callback)
if __name__ == '__main__':
appkey = "de504dc5763aeef9ff52"
pusher = pysher.Pusher(appkey)
pusher.connection.bind('pusher:connection_established', connect_handler)
pusher.connect()
while True:
index += 1
sleep(0.01)
import RPi.GPIO as GPIO
import time
import sys
from random import randint
import time
import pysher
import logging
root = logging.getLogger()
root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
root.addHandler(ch)
# from pubnub import Pubnub
pusher = pysher.Pusher('4068d8398911c1ddbbea', True, None, None, logging.INFO,
True, None, 10, 'ws-ap1.pusher.com')
def my_func(*args, **kwargs):
print("processing Args:", args)
print("processing Kwargs:", kwargs)
def _callback(m, channel):
print(m)
dc = m['brightness'] * 10
if m['item'] == 'light-living':
living.ChangeDutyCycle(dc)
import yaml
from functools import partial
from CWMetrics import CWMetrics
# Parse config
with open(sys.argv[1], 'r') as config_file:
config = yaml.load(config_file)
metrics = CWMetrics(config['exchange']['name'])
kafka_producer = KafkaProducer(
bootstrap_servers=config['kafka']['address'],
value_serializer=lambda v: json.dumps(v).encode('utf-8'))
# Init pusher
pusher = pysher.Pusher(key="de504dc5763aeef9ff52")
def orderbookHandler(symbols, dataraw):
data = json.loads(dataraw)
symbolBase = symbols.upper()[0:3]
symbolQuote = symbols.upper()[3:]
payload = {}
payload['exchange'] = "bitstamp"
payload['symbol'] = symbolBase + "/" + symbolQuote
payload['data'] = {}
payload['data']['asks'] = list(
map(lambda entry: [float(entry[0]), float(entry[1])], data['asks']))
payload['data']['bids'] = list(
map(lambda entry: [float(entry[0]), float(entry[1])], data['bids']))
payload['timestamp'] = int(float(data['microtimestamp']) / 1e3)
# HOPIN_PUSHER_KEY to the pusher key
# The latter two can be extracted with a web inspector logged into hopin.
# Upon first run, the script will perform a google authentication process,
# with the tokens stored in a local file.
#######################################
# Add a logging handler so we can see the raw communication data
import logging
root = logging.getLogger()
root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
root.addHandler(ch)
pusher = pysher.Pusher(os.environ['HOPIN_PUSHER_KEY'], cluster='eu')
service = None
DOCUMENT_ID = os.environ['HOPIN_MONITOR_GOOGLE_DOC']
# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
def message_handler(message_data):
global service
message = json.loads(message_data)
if message['body'].strip().startswith('Q:'):
question = message['body'].strip()[2:].strip()
print(f"Found question: {message['user']['name']} > {question}")
values = [[
datetime.datetime.now().strftime('%Y-%m-%d %H:%M'),
def __init__(self, pair, **kwargs):
self.pusher = pysher.Pusher(os.getenv("BITSTAMP_KEY"))
self.exchange = "Bitstamp"
self.pair = pair
self.cnx = mysql.connector.connect(**kwargs)
self.cursor = self.cnx.cursor()
