def setTrigger(self, trigger):
if not isinstance(trigger, dict):
raise TypeError("trigger parameter must be a dict instance")
if not isinstance(trigger, Trigger.Trigger):
trigger = Trigger.Trigger(trigger)
for key in trigger.keys():
if key != '*' and key is not None and not self.validateSingle(key):
raise ValueError(str(key) + ' not correct for ' + str(self.id))
self.trigger = trigger
def __init__(self, dwf, hdwf):
self.dwf = dwf
self.hdwf = hdwf
self.ch1 = Channel.Channel(self.dwf, self.hdwf, 0)
self.ch2 = Channel.Channel(self.dwf, self.hdwf, 1)
self.frequency = 100000.00
self.buffersize = 512
self.trigger = Trigger.Trigger(self.dwf, self.hdwf)
def addTriggers(self, graph):
no_heathGivers = 5
no_weaponGivers = 10
no_railguns = 5
no_rocket = 5
for i in range(no_heathGivers):
node_id = i * 29
trigger = tr.Trigger(node_id, 60, "Health_Giver", None)
self.triggers.append(trigger)
graph.nodes[node_id].extra_info = trigger
for i in range(no_railguns):
node_id = (5 + i) * 29
trigger = tr.Trigger(node_id, 100, "Weapon_Giver", "Railgun")
self.triggers.append(trigger)
graph.nodes[node_id].extra_info = trigger
for i in range(no_rocket):
node_id = (10 + i) * 29
trigger = tr.Trigger(node_id, 100, "Weapon_Giver", "Rocket")
self.triggers.append(trigger)
graph.nodes[node_id].extra_info = trigger
def __deepcopy__(self, memo):
newone = type(self)(id=self.id,
type=self.type,
label=self.label,
placeholder=self.placeholder,
required=self.required,
default=self.default,
value=self.value,
trigger={})
newone.choices = dict(self.choices)
newone.setTrigger(Trigger.Trigger(self.trigger))
return newone
async def crTrigger(ctx, *args):
if len(config.openModule) == 0:
await ctx.channel.send(embed=utility.getEmbed(
"Error: No module is open, please open a module first with .OpenModule [.om]"
))
return
argl = list(args)
if len(argl) < 2:
await ctx.channel.send(
embed=utility.getEmbed("Error: Invalid arguments"))
return
name = argl.pop(0)
mode = argl.pop(0)
if not checkArgs(mode, argl):
await ctx.channel.send(
embed=utility.getEmbed("Error: Invalid arguments"))
return
n = Trigger.Trigger(name, checkMode(mode), config.openModule[-1], argl)
config.openModule[-1].addTrigger(n)
await ctx.channel.send(embed=utility.getEmbed("Created Trigger"))
def __init__(self, name='RNA_Scan_Thread'):
pfx = 'RNA_Scan_Thread.__init__:'
msg = '%s Entering...' % pfx
msglog.log('broadway', msglog.types.INFO, msg)
self.debug = 0
# Maps file-descriptors to host-names.
self.hosts = {}
# Maps file-descriptors to sessions.
self.sessions = {}
# Maps host-names to sets of file-descriptors
self.socketmap = {}
self.connections = {}
self.bPollRun = False
self.work_queue = None
self.descriptors = set()
self.trigger_channel = Trigger(self.socketmap)
self.descriptors.add(self.trigger_channel.fileno())
msg = '%s Done.' % pfx
msglog.log('broadway', msglog.types.INFO, msg)
super(RNA_Scan_Thread, self).__init__(name=name)
def _setup_trigger_channel(self):
assert getattr(self, '_trigger_channel', None) is None
self.trigger_channel = Trigger(self)
import vk_api
from vk_api.longpoll import VkLongPoll, VkEventType
import Command
import Trigger
TOKEN = ""
BOT_ID = 283644170
ADMINS = [283644170]
PREFIX = "-->"
trigger = Trigger.Trigger()
command = Command.Command()
api = vk_api.VkApi(token=TOKEN)
longpoll = VkLongPoll(api)
vk = api.get_api()
@command.add(True)
def name(ev):
print(ev.raw)
def parseMessage(ev):
# trigger.handle(ev)
# command.handle(ev)
# event.attachments["attach1_kind"] == "audiomsg"
pass
class HTTPServer(asyncore.dispatcher):
PROTOCOL = "HTTP"
SERVER_IDENT = '%s Server (%s)' % (PROTOCOL, VERSION_STRING)
channel_class = Channel
event_channel = Trigger(REDUSA_SOCKET_MAP)
def __init__(self,
ip,
port,
user_manager,
realm,
authentication,
maintenance_interval=25,
zombie_timeout=600,
debug=0):
self.debug = debug
self.name = ip
self.port = port
self.user_manager = user_manager
self.realm = realm
self.authentication = authentication
self.maintenance_interval = maintenance_interval
self.zombie_timeout = zombie_timeout
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# Note the double-reference for backwards comatibility.
self.request_handlers = self.handlers = []
self.response_handlers = []
self.set_reuse_addr()
self.bind((ip, port))
self.listen(1024)
host, port = self.socket.getsockname()
try:
if not ip:
self.log_info('Computing default hostname', msglog.types.WARN)
ip = socket.gethostbyname(socket.gethostname())
self.name = socket.gethostbyaddr(ip)[0]
except socket.error:
self.name = ip
self.log_info('Cannot do reverse lookup', msglog.types.WARN)
self.total_clients = Counter()
self.total_requests = Counter()
self.exceptions = Counter()
self.bytes_out = Counter()
self.bytes_in = Counter()
self.log_info('Started')
def protocol(self):
return self.PROTOCOL
def __str__(self):
name = self.name
if not name:
name = self.SERVER_IDENT
if self.port:
name = '%s:%s' % (name, self.port)
return name
def log_info(self, message, type=msglog.types.INFO):
if type == msglog.types.DB and not self.debug:
return
msglog.log(str(self), type, message)
def writable(self):
return 0
def response_ready(self, channel):
self.event_channel.trigger_event()
def handle_read(self):
pass
def readable(self):
return self.accepting
def handle_connect(self):
pass
def handle_accept(self):
self.total_clients.increment()
try:
conn, addr = self.accept()
except socket.error:
# linux: on rare occasions we get a bogus socket back from
# accept. socketmodule.c:makesockaddr complains that the
# address family is unknown. We don't want the whole server
# to shut down because of this.
self.log_info('warning: server accept() threw an exception',
msglog.types.WARN)
return
except TypeError:
# unpack non-sequence. this can happen when a read event
# fires on a listening socket, but when we call accept()
# we get EWOULDBLOCK, so dispatcher.accept() returns None.
# Seen on FreeBSD3.
self.log_info('warning: server accept() threw EWOULDBLOCK',
msglog.types.WARN)
return
self.channel_class(self, conn, addr)
def install_handler(self, handler, back=0):
if isinstance(handler, Responder):
self.install_response_handler(handler, back)
else:
self.install_request_handler(handler, back)
def remove_handler(self, handler):
if isinstance(handler, Responder):
self.remove_response_handler(handler)
else:
self.remove_request_handler(handler)
def install_request_handler(self, handler, back=0):
if handler not in self.request_handlers:
if back:
self.request_handlers.append(handler)
else:
self.request_handlers.insert(0, handler)
def remove_request_handler(self, handler):
self.request_handlers.remove(handler)
def install_response_handler(self, responder, back=0):
if responder not in self.response_handlers:
if back or responder.isumbrella():
self.response_handlers.append(responder)
else:
self.response_handlers.insert(0, responder)
def remove_response_handler(self, responder):
self.response_handlers.remove(responder)
#
# REDUSA_SOCKET_MAP HACK:
#
# This section forces a Redusa specific socket_map so it will play nice
# with with other threads that use asyncore.
#
def add_channel(self, map=None):
assert map is None, 'Hack assumes that the map argument is None...'
return asyncore.dispatcher.add_channel(self, REDUSA_SOCKET_MAP)
def del_channel(self, map=None):
assert map is None, 'Hack assumes that the map argument is None...'
return asyncore.dispatcher.del_channel(self, REDUSA_SOCKET_MAP)
from pynput.keyboard import Key, Listener
import atexit
import signal
import sys
import Trigger
configs = []
################## Config ##########################
useEscapeToExit = False
showKeysLogs = True
#### Your Apps ####
discord = Trigger.Trigger(
"disc", True,
'\"C:\\Users\\Fuking useless shit\\AppData\\Local\\Discord\\Update.exe\" --processStart Discord.exe',
"Discord.exe")
configs.append(discord)
firefox = Trigger.Trigger("fire", True,
'\"C:\\Program Files\\Mozilla Firefox\\firefox.exe',
"firefox.exe")
configs.append(firefox)
####################################################
def on_press(key):
global configs
for trigger in configs:
trigger.check_sequence(key)
if key == Key.esc and useEscapeToExit:
return False
if showKeysLogs:
print(str(key))
