def _item_resolution_scope(scope):
output = Object(prototype=scope)
output._can_resolve_items = False
# output.parent = scope
# logger.debug('item resolution scope {} (for {})'.format(output._id, scope._id))
return output
def _item_resolution_scope(scope):
output = Object(prototype=scope)
output._can_resolve_items = False
# output.parent = scope
# logger.debug('item resolution scope {} (for {})'.format(output._id, scope._id))
return output
def _new_with_arguments(prototype, arguments, arguments_scope):
if prototype.arguments == arguments and prototype.arguments_scope == arguments_scope:
return prototype
output = Object(prototype=prototype)
output.arguments = arguments
output.arguments_scope = arguments_scope
# logger.debug('arguments scope {} (for {})'.format(output._id, prototype._id))
return output
def _new_with_arguments(prototype, arguments, arguments_scope):
if prototype.arguments == arguments and prototype.arguments_scope == arguments_scope:
return prototype
output = Object(prototype=prototype)
output.arguments = arguments
output.arguments_scope = arguments_scope
# logger.debug('arguments scope {} (for {})'.format(output._id, prototype._id))
return output
def _create_native(value):
output = Object()
output.items = {
'or': LV(lambda: create_scope(
defaults=[('other', None)],
expression=LV(lambda: resolve('self'))
)),
'then': LV(lambda: create_scope(
defaults=[('callable', None)],
expression=LV(lambda: call(resolve('callable'), [(None, LV(lambda: resolve('self')))]))
)),
}
output.parent = scope_stack[0]
output.arguments_scope = output.parent
output.raw = value
logger.debug('create native {} {}'.format(output._id, value))
return output
def __new__(cls, text, description=None):
assert isinstance(text, str)
text = text.strip()
assert 0 < len(text) <= cls._maxlen
assert not re.match(r"[\n\r\t]", text)
examples = [Example(text, created=datetime.now())]
return Object(intent=uuid(),
description=description,
examples=examples)
def __new__(cls, intent, text):
assert isinstance(text, str)
text = text.strip()
assert 0 < len(text) <= cls._maxlen
values = [DialogNodeText(text)]
generic = [DialogNodeOutputGeneric('text', values)]
output = DialogNodeOutput(generic)
name = intent.intent
return Object(dialog_node=name,
description=intent.description,
conditions=f'#{name}',
output=output)
def getBigramMaxesAndMins(bigrams):
def ni(x):
return x[x != float("-Inf")]
maxes = Object()
maxes.fullLength = np.max([np.max(ni(b.fullLength)) for b in bigrams])
maxes.gap = np.max([np.max(ni(b.gap)) for b in bigrams])
maxes.startStart = np.max([np.max(ni(b.startStart)) for b in bigrams])
mins = Object()
mins.fullLength = np.min([np.min(ni(b.fullLength)) for b in bigrams])
mins.gap = np.min([np.min(ni(b.gap)) for b in bigrams])
mins.startStart = np.min([np.min(ni(b.startStart)) for b in bigrams])
return (maxes, mins)
def compileBigramModel(data):
COUNT_CUTOFF = 5
TIME_CUTOFF = 5
bigramModel = data.bigramModel
keycodes = sorted(list(KEYCODES.values()))
keyToIndex = dict((v, k) for (k, v) in enumerate(keycodes))
fullLength = np.zeros([len(keycodes)] * 2) + float("-Inf")
gap = np.zeros([len(keycodes)] * 2) + float("-Inf")
startStart = np.zeros([len(keycodes)] * 2) + float("-Inf")
for (k, v) in bigramModel.iteritems():
for (m, n) in v.iteritems():
(fl, g, ss) = zip(*n)
if len(fl) >= COUNT_CUTOFF and abs(np.mean(fl)) < TIME_CUTOFF:
fullLength[keyToIndex[k], keyToIndex[m]] = np.mean(fl)
if len(g) >= COUNT_CUTOFF and abs(np.mean(g)) < TIME_CUTOFF:
gap[keyToIndex[k], keyToIndex[m]] = np.mean(g)
if len(ss) >= COUNT_CUTOFF and abs(np.mean(ss)) < TIME_CUTOFF:
startStart[keyToIndex[k], keyToIndex[m]] = np.mean(ss)
bigram = Object()
bigram.fullLength = fullLength
bigram.gap = gap
bigram.startStart = startStart
return bigram
def put_job(self):
if self.busy: return
temperature = self.get_temperature()
if temperature < self.cutoff_temp:
response = request(self.device, b'ZDX')
if self.is_ok(response):
if self.switch.update_time:
self.job.time = bytereverse(
uint32(long(time())) - self.job.time_delta)
data = b''.join([
pack('<8I', *self.job.state),
pack('<3I', self.job.merkle_end, self.job.time,
self.job.difficulty)
])
response = request(self.device,
b''.join([b'>>>>>>>>', data, b'>>>>>>>>']))
if self.is_ok(response):
self.busy = True
self.job_started = time()
self.last_job = Object()
self.last_job.header = self.job.header
self.last_job.merkle_end = self.job.merkle_end
self.last_job.time = self.job.time
self.last_job.difficulty = self.job.difficulty
self.last_job.target = self.job.target
self.last_job.state = self.job.state
self.last_job.job_id = self.job.job_id
self.last_job.extranonce2 = self.job.extranonce2
self.last_job.server = self.job.server
self.last_job.miner = self
self.check_interval = CHECK_INTERVAL
if not self.switch.update_time or bytereverse(
self.job.time) - bytereverse(
self.job.original_time) > 55:
self.update = True
self.job = None
else:
say_line('%s: bad response when sending block data: %s',
(self.id(), response))
else:
say_line('%s: bad response when submitting job (ZDX): %s',
(self.id(), response))
else:
say_line('%s: temperature exceeds cutoff, waiting...', self.id())
def _create_native(value):
output = Object()
output.items = {
'or':
LV(lambda: create_scope(defaults=[('other', None)],
expression=LV(lambda: resolve('self')))),
'then':
LV(lambda: create_scope(defaults=[('callable', None)],
expression=LV(lambda: call(
resolve('callable'),
[(None, LV(lambda: resolve('self')))])))),
}
output.parent = scope_stack[0]
output.arguments_scope = output.parent
output.raw = value
logger.debug('create native {} {}'.format(output._id, value))
return output
def decode(self,
server,
block_header,
target,
job_id=None,
extranonce2=None):
if block_header:
job = Object()
binary_data = block_header.decode('hex')
data0 = np.zeros(64, np.uint32)
data0 = np.insert(data0, [0] * 16,
unpack('IIIIIIIIIIIIIIII', binary_data[:64]))
job.target = np.array(unpack('IIIIIIII', target.decode('hex')),
dtype=np.uint32)
job.header = binary_data[:68]
job.merkle_end = np.uint32(unpack('I', binary_data[64:68])[0])
job.time = np.uint32(unpack('I', binary_data[68:72])[0])
job.difficulty = np.uint32(unpack('I', binary_data[72:76])[0])
job.state = sha256(STATE, data0)
job.f = np.zeros(8, np.uint32)
job.state2 = partial(job.state, job.merkle_end, job.time,
job.difficulty, job.f)
job.targetQ = 2**256 / int(''.join(list(chunks(target, 2))[::-1]),
16)
job.job_id = job_id
job.extranonce2 = extranonce2
job.server = server
calculateF(job.state, job.merkle_end, job.time, job.difficulty,
job.f, job.state2)
if job.difficulty != self.difficulty:
self.set_difficulty(job.difficulty)
return job
def parse_server(self, server, mailAsUser=True):
s = Object()
temp = server.split('://', 1)
if len(temp) == 1:
s.proto = ''
temp = temp[0]
else:
s.proto = temp[0]
temp = temp[1]
if mailAsUser:
s.user, temp = temp.split(':', 1)
s.pwd, s.host = temp.split('@')
else:
temp = temp.split('@', 1)
if len(temp) == 1:
s.user = ''
s.pwd = ''
s.host = temp[0]
else:
if temp[0].find(':') <> -1:
s.user, s.pwd = temp[0].split(':')
else:
s.user = temp[0]
s.pwd = ''
s.host = temp[1]
if s.host.find('#') != -1:
s.host, s.name = s.host.split('#')
else:
s.name = s.host
return s
def decode(self, server, block_header, target, job_id = None, extranonce2 = None):
if block_header:
job = Object()
binary_data = block_header.decode('hex')
data0 = list(unpack('<16I', binary_data[:64])) + ([0] * 48)
job.target = unpack('<8I', target.decode('hex'))
job.header = binary_data[:68]
job.merkle_end = uint32(unpack('<I', binary_data[64:68])[0])
job.time = uint32(unpack('<I', binary_data[68:72])[0])
job.difficulty = uint32(unpack('<I', binary_data[72:76])[0])
job.state = sha256(STATE, data0)
job.targetQ = 2**256 / int(''.join(list(chunks(target, 2))[::-1]), 16)
job.job_id = job_id
job.extranonce2 = extranonce2
job.server = server
if job.difficulty != self.difficulty:
self.set_difficulty(job.difficulty)
return job
def decode(self, server, block_header, target, job_id = None, extranonce2 = None):
if block_header:
job = Object()
binary_data = block_header.decode('hex')
data0 = np.zeros(64, np.uint32)
data0 = np.insert(data0, [0] * 16, unpack('IIIIIIIIIIIIIIII', binary_data[:64]))
job.target = np.array(unpack('IIIIIIII', target.decode('hex')), dtype=np.uint32)
job.header = binary_data[:68]
job.merkle_end = np.uint32(unpack('I', binary_data[64:68])[0])
job.time = np.uint32(unpack('I', binary_data[68:72])[0])
job.difficulty = np.uint32(unpack('I', binary_data[72:76])[0])
job.state = sha256(STATE, data0)
job.f = np.zeros(8, np.uint32)
job.state2 = partial(job.state, job.merkle_end, job.time, job.difficulty, job.f)
job.targetQ = 2**256 / int(''.join(list(chunks(target, 2))[::-1]), 16)
job.job_id = job_id
job.extranonce2 = extranonce2
job.server = server
calculateF(job.state, job.merkle_end, job.time, job.difficulty, job.f, job.state2)
if job.difficulty != self.difficulty:
self.set_difficulty(job.difficulty)
return job
def collectData(infile):
data = Object()
userName = os.path.split(infile.name)[1].split(".")[0]
# initialize all the container vars
keystrokePLs = []
keystrokePLs_key = defaultdict(list)
keystrokePLs_domain = defaultdict(list)
keystrokeFreqs = [0] * 250
sessionLengths = []
keystrokesPressedPerSession = []
timeSpentPressingKeys = []
websitesVisitedPerSession = []
domainsVisitedPerSession = []
domainVisits = Counter()
websiteVisitLength = [] # can't currently get this one
websiteVisitLength_domain = defaultdict(list) # same here
wordLengths = [] # TODO implement
wordDurations = [] # TODO implement
# Bigram model stuff
bigramModel = defaultdict(lambda: defaultdict(list))
# go through the segmented data (this is just a lot of code)
stream = openJsonStream(infile)
sessions = segmentJsonStream(stream)
for session in sessions:
keystrokesPressed = 0
timeSpent = 0.0
domains = set()
websites = set()
for page in session.data:
if page.url is None:
domain = "*"
page.url = "*"
else:
domain = urlparse(page.url).netloc
websites.add(page.url)
domains.add(domain)
domainVisits.update([domain])
keystrokesPressed += len(page.keystrokes)
page.keystrokes.sort(key=lambda x: x.timestamp)
pKey = None
pStart = 0
pEnd = 0
for keystroke in page.keystrokes:
pl = keystroke.pressLength
kc = keystroke.keycode
start = keystroke.timestamp / 1000.0
end = start + pl
keystrokePLs.append(pl)
keystrokePLs_key[kc].append(pl)
keystrokePLs_domain[domain].append(pl)
keystrokeFreqs[kc] += 1
if pKey is not None:
bigramModel[pKey][kc].append((end - pStart, start - pEnd, start - pStart))
pKey = kc
pStart = start
pEnd = end
timeSpent += keystroke.pressLength
sessionLengths.append(session.time)
keystrokesPressedPerSession.append(keystrokesPressed)
if session.time > 0.0:
timeSpentPressingKeys.append(timeSpent / float(session.time))
websitesVisitedPerSession.append(len(websites))
domainsVisitedPerSession.append(len(domains))
# store them all in data.
data.keystrokePLs = np.array(keystrokePLs)
data.keystrokePLs_key = dict((k, np.array(v)) for (k, v) in keystrokePLs_key.iteritems())
data.keystrokePLs_domain = dict((k, np.array(v)) for (k, v) in keystrokePLs_domain.iteritems())
data.keystrokeFreqs = np.array(keystrokeFreqs)
data.sessionLengths = np.array(sessionLengths)
data.keystrokesPressedPerSession = np.array(keystrokesPressedPerSession)
data.timeSpentPressingKeys = np.array(timeSpentPressingKeys)
data.websitesVisitedPerSession = np.array(websitesVisitedPerSession)
data.domainsVisitedPerSession = np.array(domainsVisitedPerSession)
data.domainVisits = domainVisits
data.websiteVisitLength = websiteVisitLength # TODO implement
data.websiteVisitLength_domain = websiteVisitLength_domain # TODO implement
data.wordLengths = np.array(wordLengths) # TODO implement
data.wordDurations = np.array(wordDurations) # TODO implement
data.bigramModel = bigramModel
data.user = userName
# TODO: finish
return data
def decode(self, server, block_header, target, job_id = None, extranonce2 = None):
if block_header:
job = Object()
binary_data = block_header.decode('hex')
#data0 = list(unpack('<16I', binary_data[:64])) + ([0] * 48)
job.headerX = binary_data[:76]
job.dataX = unpack('<19I', job.headerX)
job.target = unpack('<8I', target.decode('hex'))
job.header = binary_data[:68]
job.merkle_end = uint32(unpack('<I', binary_data[64:68])[0])
job.time = uint32(unpack('<I', binary_data[68:72])[0])
job.difficulty = uint32(unpack('<I', binary_data[72:76])[0])
# job.state = sha256(STATE, data0)
job.targetQ = 2**256 / int(''.join(list(chunks(target, 2))[::-1]), 16)
job.job_id = job_id
job.extranonce2 = extranonce2
job.server = server
if job.difficulty != self.difficulty:
self.set_difficulty(job.difficulty)
return job
def parse_server(self, server, mailAsUser=True):
s = Object()
temp = server.split('://', 1)
if len(temp) == 1:
s.proto = ''; temp = temp[0]
else: s.proto = temp[0]; temp = temp[1]
if mailAsUser:
s.user, temp = temp.split(':', 1)
s.pwd, s.host = temp.split('@')
else:
temp = temp.split('@', 1)
if len(temp) == 1:
s.user = ''
s.pwd = ''
s.host = temp[0]
else:
if temp[0].find(':') <> -1:
s.user, s.pwd = temp[0].split(':')
else:
s.user = temp[0]
s.pwd = ''
s.host = temp[1]
if s.host.find('#') != -1:
s.host, s.name = s.host.split('#')
else: s.name = s.host
return s
except Exception as e:
logger.debug(e) # TODO narrow down exceptions
return create_failed(e)
def evaluate_module(items={}, expression=None):
module = create_scope(items=items, expression=expression)
return call(module, [])
_import_cache = {}
def _import(path):
if path.raw in _import_cache:
return _import_cache[path.raw]
try:
source = modules[path.raw]
node = _parser.parse(source)
_import_cache[path] = node
return node
except KeyError as e:
return create_failed("No such module: {}".format(path.raw))
# bootstrap scope_stack
scope_stack = []
root = Object()
scope_stack.append(root)
def _new_with_self(prototype, self):
output = Object(prototype=prototype)
output.self = self
# logger.debug('self scope {} (for {})'.format(output._id, prototype._id))
return output
def mining_thread(self):
say_line('started OpenCL miner on platform %d, device %d (%s)', (self.options.platform, self.device_index, self.device_name))
(self.defines, rate_divisor, hashspace) = if_else(self.vectors, ('-DVECTORS', 500, 0x7FFFFFFF), ('', 1000, 0xFFFFFFFF))
self.defines += (' -DOUTPUT_SIZE=' + str(self.output_size))
self.defines += (' -DOUTPUT_MASK=' + str(self.output_size - 1))
self.load_kernel()
frame = 1.0 / max(self.frames, 3)
unit = self.worksize * 256
global_threads = unit * 10
queue = cl.CommandQueue(self.context)
last_rated_pace = last_rated = last_n_time = last_temperature = time()
base = last_hash_rate = threads_run_pace = threads_run = 0
output = np.zeros(self.output_size + 1, np.uint32)
output_buffer = cl.Buffer(self.context, cl.mem_flags.WRITE_ONLY | cl.mem_flags.USE_HOST_PTR, hostbuf=output)
self.kernel.set_arg(20, output_buffer)
work = None
temperature = 0
while True:
if self.should_stop: return
sleep(self.frameSleep)
if (not work) or (not self.work_queue.empty()):
try:
work = self.work_queue.get(True, 1)
except Empty: continue
else:
if not work: continue
nonces_left = hashspace
state = work.state
state2 = work.state2
f = work.f
self.kernel.set_arg(0, state[0])
self.kernel.set_arg(1, state[1])
self.kernel.set_arg(2, state[2])
self.kernel.set_arg(3, state[3])
self.kernel.set_arg(4, state[4])
self.kernel.set_arg(5, state[5])
self.kernel.set_arg(6, state[6])
self.kernel.set_arg(7, state[7])
self.kernel.set_arg(8, state2[1])
self.kernel.set_arg(9, state2[2])
self.kernel.set_arg(10, state2[3])
self.kernel.set_arg(11, state2[5])
self.kernel.set_arg(12, state2[6])
self.kernel.set_arg(13, state2[7])
self.kernel.set_arg(15, f[0])
self.kernel.set_arg(16, f[1])
self.kernel.set_arg(17, f[2])
self.kernel.set_arg(18, f[3])
self.kernel.set_arg(19, f[4])
if temperature < self.cutoff_temp:
self.kernel.set_arg(14, pack('I', base))
cl.enqueue_nd_range_kernel(queue, self.kernel, (global_threads,), (self.worksize,))
nonces_left -= global_threads
threads_run_pace += global_threads
threads_run += global_threads
base = uint32(base + global_threads)
else:
threads_run_pace = 0
last_rated_pace = time()
sleep(self.cutoff_interval)
now = time()
if self.adapterIndex != None:
t = now - last_temperature
if temperature >= self.cutoff_temp or t > 1:
last_temperature = now
with adl_lock:
temperature = self.get_temperature()
t = now - last_rated_pace
if t > 1:
rate = (threads_run_pace / t) / rate_divisor
last_rated_pace = now; threads_run_pace = 0
r = last_hash_rate / rate
if r < 0.9 or r > 1.1:
global_threads = max(unit * int((rate * frame * rate_divisor) / unit), unit)
last_hash_rate = rate
t = now - last_rated
if t > self.options.rate:
self.update_rate(now, threads_run, t, work.targetQ, rate_divisor)
last_rated = now; threads_run = 0
queue.finish()
cl.enqueue_read_buffer(queue, output_buffer, output)
queue.finish()
if output[self.output_size]:
result = Object()
result.header = work.header
result.merkle_end = work.merkle_end
result.time = work.time
result.difficulty = work.difficulty
result.target = work.target
result.state = np.array(state)
result.nonces = np.array(output)
result.job_id = work.job_id
result.extranonce2 = work.extranonce2
result.server = work.server
result.miner = self
self.switch.put(result)
output.fill(0)
cl.enqueue_write_buffer(queue, output_buffer, output)
if not self.switch.update_time:
if nonces_left < 3 * global_threads * self.frames:
self.update = True
nonces_left += 0xFFFFFFFFFFFF
elif 0xFFFFFFFFFFF < nonces_left < 0xFFFFFFFFFFFF:
say_line('warning: job finished, %s is idle', self.id())
work = None
elif now - last_n_time > 1:
work.time = bytereverse(bytereverse(work.time) + 1)
state2 = partial(state, work.merkle_end, work.time, work.difficulty, f)
calculateF(state, work.merkle_end, work.time, work.difficulty, f, state2)
self.kernel.set_arg(8, state2[1])
self.kernel.set_arg(9, state2[2])
self.kernel.set_arg(10, state2[3])
self.kernel.set_arg(11, state2[5])
self.kernel.set_arg(12, state2[6])
self.kernel.set_arg(13, state2[7])
self.kernel.set_arg(15, f[0])
self.kernel.set_arg(16, f[1])
self.kernel.set_arg(17, f[2])
self.kernel.set_arg(18, f[3])
self.kernel.set_arg(19, f[4])
last_n_time = now
self.update_time_counter += 1
if self.update_time_counter >= self.switch.max_update_time:
self.update = True
self.update_time_counter = 1
def mining_thread(self):
say_line('started OpenCL miner on platform %d, device %d (%s)', (self.options.platform, self.device_index, self.device_name))
(self.defines, rate_divisor, hashspace) = ('', 1000, 0xFFFFFFFF)
self.defines += (' -D%sOUTPUT_SIZE=%s' % (self.defspace, str(self.output_size)))
self.defines += (' -D%sOUTPUT_MASK=%s' % (self.defspace, str(self.output_size - 1)))
self.defines += (' -D%sENDIAN_LITTLE=%d' % (self.defspace, self.device.endian_little))
self.defines += (' -D%sGPU_AMD=%d' % (self.defspace, self.gpu_amd))
self.defines += (' -I%s%s' % (self.defspace, os.getcwd()))
say_line("Compiler defines: %s", self.defines)
self.load_kernel()
frame = 1.0 / max(self.frames, 3)
unit = self.worksize * 256
global_threads = unit * 10
queue = cl.CommandQueue(self.context)
last_rated_pace = last_rated = last_n_time = last_temperature = time()
base = last_hash_rate = threads_run_pace = threads_run = 0
output = bytearray((self.output_size + 1) * 4)
output_buffer = cl.Buffer(self.context, cl.mem_flags.WRITE_ONLY | cl.mem_flags.USE_HOST_PTR, hostbuf=output)
self.kernel.set_arg(12, output_buffer)
work = None
temperature = 0
while True:
if self.should_stop: return
sleep(self.frameSleep)
if (not work) or (not self.work_queue.empty()):
try:
work = self.work_queue.get(True, 1)
except Empty: continue
else:
if not work: continue
nonces_left = hashspace
self.queue_kernel_parameters(work)
if temperature < self.cutoff_temp:
self.kernel.set_arg(11, pack('<I', base))
cl.enqueue_nd_range_kernel(queue, self.kernel, (global_threads,), (self.worksize,))
nonces_left -= global_threads
threads_run_pace += global_threads
threads_run += global_threads
base = uint32(base + global_threads)
else:
threads_run_pace = 0
last_rated_pace = time()
sleep(self.cutoff_interval)
now = time()
if self.adapterIndex is not None:
t = now - last_temperature
if temperature >= self.cutoff_temp or t > 1:
last_temperature = now
with adl_lock:
self.temperature = self.get_temperature()
temperature = self.temperature
t = now - last_rated_pace
if t > 1:
rate = (threads_run_pace / t) / rate_divisor
last_rated_pace = now; threads_run_pace = 0
r = last_hash_rate / rate
if r < 0.9 or r > 1.1:
global_threads = max(unit * int((rate * frame * rate_divisor) / unit), unit)
last_hash_rate = rate
t = now - last_rated
if t > self.options.rate:
self.update_rate(now, threads_run, t, work.targetQ, rate_divisor)
last_rated = now; threads_run = 0
queue.finish()
cl.enqueue_read_buffer(queue, output_buffer, output)
queue.finish()
if output[-1]:
result = Object()
result.header = work.header
result.headerX = work.headerX
result.merkle_end = work.merkle_end
result.time = work.time
result.difficulty = work.difficulty
result.target = work.target
result.dataX = work.dataX[:]
result.nonces = output[:]
result.job_id = work.job_id
result.extranonce2 = work.extranonce2
result.server = work.server
result.miner = self
self.switch.put(result)
output[:] = b'\x00' * len(output)
cl.enqueue_write_buffer(queue, output_buffer, output)
for miner in self.switch.miners:
miner.update = True
if not self.switch.update_time:
if nonces_left < 6 * global_threads * self.frames:
self.update = True
nonces_left += 0xFFFFFFFFFFFF
elif 0xFFFFFFFFFFF < nonces_left < 0xFFFFFFFFFFFF:
say_line('warning: job finished, %s is idle', self.id())
work = None
elif now - last_n_time > 1:
last_n_time = now
self.update_time_counter += 1
if self.update_time_counter >= self.switch.max_update_time:
self.update = True
self.update_time_counter = 1
def handle_message(self, message):
#Miner API
if 'method' in message:
#mining.notify
if message['method'] == 'mining.notify':
params = message['params']
j = Object()
j.job_id = params[0]
j.prevhash = params[1]
j.coinbase1 = params[2]
j.coinbase2 = params[3]
j.merkle_branch = params[4]
j.version = params[5]
j.nbits = params[6]
j.ntime = params[7]
clear_jobs = params[8]
if clear_jobs:
self.jobs.clear()
j.extranonce2 = self.extranonce2_size * '00'
j = self.refresh_job(j)
self.jobs[j.job_id] = j
self.current_job = j
self.queue_work(j)
self.switch.connection_ok()
#mining.get_version
if message['method'] == 'mining.get_version':
with self.send_lock:
self.send_message({"error": None, "id": message['id'], "result": self.user_agent})
#mining.set_difficulty
elif message['method'] == 'mining.set_difficulty':
say_line("Setting new difficulty: %s", message['params'][0])
self.server_difficulty = BASE_DIFFICULTY / message['params'][0]
#client.reconnect
elif message['method'] == 'client.reconnect':
address, port = self.server().host.split(':', 1)
(new_address, new_port, timeout) = message['params'][:3]
if new_address: address = new_address
if new_port != None: port = new_port
say_line("%s asked us to reconnect to %s:%d in %d seconds", (self.server().name, address, port, timeout))
self.server().host = address + ':' + str(port)
Timer(timeout, self.reconnect).start()
#client.add_peers
elif message['method'] == 'client.add_peers':
hosts = [{'host': host[0], 'port': host[1]} for host in message['params'][0]]
self.switch.add_servers(hosts)
#responses to server API requests
elif 'result' in message:
#response to mining.subscribe
#store extranonce and extranonce2_size
if message['id'] == 's':
self.extranonce = message['result'][1]
self.extranonce2_size = message['result'][2]
self.subscribed = True
#check if this is submit confirmation (message id should be in submits dictionary)
#cleanup if necessary
elif message['id'] in self.submits:
miner, nonce = self.submits[message['id']][:2]
accepted = message['result']
self.switch.report(miner, nonce, accepted)
del self.submits[message['id']]
if time() - self.last_submits_cleanup > 3600:
now = time()
for key, value in self.submits.items():
if now - value[2] > 3600:
del self.submits[key]
self.last_submits_cleanup = now
#response to mining.authorize
elif message['id'] == self.server().user:
if not message['result']:
say_line('authorization failed with %s:%s@%s', (self.server().user, self.server().pwd, self.server().host))
self.authorized = False
else:
self.authorized = True
def _new_with_self(prototype, self):
output = Object(prototype=prototype)
output.self = self
# logger.debug('self scope {} (for {})'.format(output._id, prototype._id))
return output
def handle_message(self, message):
#Miner API
if 'method' in message:
#mining.notify
if message['method'] == 'mining.notify':
params = message['params']
j = Object()
j.job_id = params[0]
j.prevhash = params[1]
j.coinbase1 = params[2]
j.coinbase2 = params[3]
j.merkle_branch = params[4]
j.version = params[5]
j.nbits = params[6]
j.ntime = params[7]
clear_jobs = params[8]
if clear_jobs:
self.jobs.clear()
j.extranonce2 = self.extranonce2_size * '00'
j = self.refresh_job(j)
self.jobs[j.job_id] = j
self.current_job = j
self.queue_work(j)
self.switch.connection_ok()
#mining.get_version
if message['method'] == 'mining.get_version':
with self.send_lock:
self.send_message({
"error": None,
"id": message['id'],
"result": self.user_agent
})
#mining.set_difficulty
elif message['method'] == 'mining.set_difficulty':
say_line("Setting new difficulty: %s", message['params'][0])
self.server_difficulty = BASE_DIFFICULTY / message['params'][0]
#client.reconnect
elif message['method'] == 'client.reconnect':
address, port = self.server().host.split(':', 1)
(new_address, new_port, timeout) = message['params'][:3]
if new_address: address = new_address
if new_port != None: port = new_port
say_line("%s asked us to reconnect to %s:%d in %d seconds",
(self.server().name, address, port, timeout))
self.server().host = address + ':' + str(port)
Timer(timeout, self.reconnect).start()
#client.add_peers
elif message['method'] == 'client.add_peers':
hosts = [{
'host': host[0],
'port': host[1]
} for host in message['params'][0]]
self.switch.add_servers(hosts)
#responses to server API requests
elif 'result' in message:
#response to mining.subscribe
#store extranonce and extranonce2_size
if message['id'] == 's':
self.extranonce = message['result'][1]
self.extranonce2_size = message['result'][2]
self.subscribed = True
#check if this is submit confirmation (message id should be in submits dictionary)
#cleanup if necessary
elif message['id'] in self.submits:
miner, nonce = self.submits[message['id']][:2]
accepted = message['result']
self.switch.report(miner, nonce, accepted)
del self.submits[message['id']]
if time() - self.last_submits_cleanup > 3600:
now = time()
for key, value in self.submits.items():
if now - value[2] > 3600:
del self.submits[key]
self.last_submits_cleanup = now
#response to mining.authorize
elif message['id'] == self.server().user:
if not message['result']:
say_line('authorization failed with %s:%s@%s',
(self.server().user, self.server().pwd,
self.server().host))
self.authorized = False
else:
self.authorized = True
res = cls._search(params=params)
if not res.ok:
return []
return munchify(res.json()).query.search
@classmethod
def snippets(cls, query, count=None):
return [Snippet(e) for e in cls(query, 'snippet', count)]
@classmethod
def snippet(cls, query):
ret = cls.snippets(query, 1)
return ret[0] if ret else None
_units = Object(metric='m', imperial='e')
units_ = Object(m='metric', e='imperial')
Precipitation = namedtuple('Precipitation', 'total hourly snow')
class Value(dict):
def __init__(self, units, type):
super().__init__()
self._units = units
self._unit = Units[units].get(type, '')
def _format(self, key):
return f"{self[key]}{self._unit}"
