def to_unique_object(self, response: Dict[str, Any]) -> T:
if response['Count'] == 0:
return None
if response['Count'] > 1:
Log.error(f'Received invalid DDB response: {response}')
raise InternalBotException('Received invalid DDB response')
return self._to_object(response['Items'][0])
def extract_videos(basepath):
Logger.debug("Generating videos")
extractDir = basepath + "/extracted"
infoFile = basepath + "/info.json"
if not os.path.exists(infoFile):
Logger.error("info file not found! Exiting.")
return
with open(infoFile) as f:
info = json.load(f)
# generate videos
videoDir = basepath + '/videos'
for topic in info['topics']:
topicName = topic['topic']
msgType = topic['type']
# create videos from only the left lens/camera
if msgType == 'sensor_msgs/Image' and 'left' in topicName:
imagesDir = extractDir + topicName
if not os.path.exists(imagesDir):
Logger.error("Doesn't exist - " + imagesDir)
continue
make_dirs(videoDir)
filename = topicName.replace('image_raw', '').replace('left', 'Left').replace('/', '') + '.mp4'
videoFile = videoDir + '/' + filename
Logger.debug('creating ' + videoFile)
makeVideo(imagesDir, output=videoFile, fps=10)
# Annotations dir for storing video comments
annotDir = basepath + '/annotations'
make_dirs(annotDir)
os.chmod(annotDir, stat.S_IRWXU | stat.S_IRWXG | stat.S_ISGID | stat.S_IRWXO)
def shell_ls(pathToLS,
showFiles=True,
showDirs=True,
showHiden=False,
absolutePath=True):
"""
As shell ls.
"""
results = []
try:
allItems = os.walk(pathToLS)
for root, dirs, files in allItems:
if showDirs:
for d in dirs:
if d[0] != "." or showHiden:
if absolutePath:
r = path_join(root, d)
else:
r = d
results.append(r)
if showFiles:
for f in files:
if f[0] != "." or showHiden:
if absolutePath:
r = path_join(root, f)
else:
r = f
results.append(r)
# Only show depth=1.
break
except Exception as e:
Logger.error("Error occured while walk through: {}".format(str(e)))
return results
def substitute_str_in_file(inputFile, orgStr, tarStr, outputFile=None):
"""
Substitute string in file.
"""
if not is_file_existing(inputFile):
Logger.error("Input file is not existing: {}".format(inputFile))
return False
tmpFile = generate_temp_file()
proc = subprocess.Popen(["cp", inputFile, tmpFile])
proc.wait()
if proc.returncode:
return False
# TODO:
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Caution here for '/' in strings.
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
shellCmd = [
"sed", "-i", "s/{}/{}/g".format(str(orgStr), str(tarStr)), tmpFile
]
proc = subprocess.Popen(shellCmd)
proc.wait()
if proc.returncode:
return False
if not outputFile:
outputFile = inputFile
proc = subprocess.Popen(["cp", tmpFile, outputFile])
proc.wait()
if proc.returncode:
return False
return True
class StartUpLems():
"""
Start up of local energy management system
"""
def __init__(self, socket):
self.t0 = time.time()
self.Conenction_time_max = 1
self.logger = Logger("Local_ems_start_up")
self.Operation_mode = default_operation_mode[
"UEMS"] # 1=Work as a universal EMS; 2=Work as a local EMS.
self.socket = socket
def run(self):
"""
Communication check of the neighboring MGs
:return: Operation mode
"""
self.socket.send(b"ConnectionRequest")
connection_thread = ConnectionThread(self.socket)
connection_thread.daemon = True
connection_thread.start()
connection_thread.join(self.Conenction_time_max)
try:
if connection_thread.message == b"Start!":
self.logger.info(
"The connection between the local EMS and universal EMS establishes!"
)
except:
self.logger.error("Connection is timeout!")
self.logger.warning("EMS works as a local ems now!")
self.Operation_mode = default_operation_mode[
"LEMS"] # Change the working mode of universal energy management system
return self.Operation_mode
def information_send(self, microgrid, static_info):
"""
Collection information from local energy management systems
:param microgrid: static information models of energy management system
:param static_info: information model of static information models
:return: the status of information sent
"""
static_info_formulated = static_information_formulation(
microgrid, static_info)
info_send = InformationSendReceive(self.socket, static_info_formulated)
static_info_status = info_send.send()
return static_info_status
def database_start_up(self):
"""
Create database session for the local energy management system
:return: Session class
"""
Session = db_session(scheduling_plan_local)
return Session
def respData(self):
"""
Return response data.
"""
if self.__response is None:
Logger.error("Launch request first.")
return None
return self.__response.content
def respHeaders(self):
"""
Return response headers.
"""
if self.__response is None:
Logger.error("Launch request first.")
return None
return self.__response.headers
def respStatusCode(self):
"""
Return response status code.
"""
if self.__response is None:
Logger.error("Launch request first.")
return None
return self.__response.status_code
def headers(self, value):
"""
Set headers.
"""
if not isinstance(value, dict):
Logger.error("Set headers of http client failed.")
return False
self.__headers = value
return True
def path(self, value):
"""
Set path.
"""
if not isinstance(value, str):
Logger.error("Set path of http client failed.")
return False
self.__path = value.lstrip('/')
return True
def port(self, value):
"""
Set port.
"""
if not isinstance(value, int) or value < 0 or value > 65535:
Logger.error("Set port of http client failed.", value)
return False
self.__port = value
return True
def host(self, value):
"""
Set host.
"""
if not isinstance(value, str):
Logger.error("Set host of http client failed.")
return False
self.__host = value.rstrip('/')
return True
def url(self, value):
"""
Set url.
"""
if not isinstance(value, str):
Logger.error("Set url of http client failed.")
return False
self.__url = value
return True
def doPost(self, value):
"""
Set doPost.
"""
if not isinstance(value, bool):
Logger.error("Set doPost of http client failed.")
return False
self.__doPost = value
return True
def json_loads(inputStr):
"""
Load str to dict.
"""
try:
result = json.loads(inputStr)
except Exception as e:
Logger.error("Json load failed: {}".format(str(e)))
return None
return result
def join_smalltv(self,obj):
if self.num==200:
print('[跳过抽奖]['+obj['title']+']已跳过抽奖(roomid=' + str(obj['roomid'])+ ',raffleId=' + str(obj['raffleId'])+ ')')
return
self.num+=1
res=API.Gift.join_smalltv(self.s,obj['roomid'], obj['raffleId'],self.Info['csrf_token'],self.Info['visit_id'])
code=res['code']
if code==0:Logger.info('[自动抽奖]['+obj['title']+']已参加抽奖(roomid=' + str(obj['roomid'])+ ',raffleId=' + str(obj['raffleId'])+ ')')
elif code==400:Logger.warning('[自动抽奖][礼物抽奖]访问被拒绝，您的帐号可能已经被封禁，已停止')
elif code==65531:Logger.info('[自动抽奖][礼物抽奖]已参加抽奖(roomid=' + str(obj['roomid'])+ ',raffleId=' + str(obj['raffleId'])+ ')')
else:Logger.error('[自动抽奖][礼物抽奖]已参加抽奖(roomid=' + str(obj['roomid'])+ ',raffleId=' + str(obj['raffleId'])+ ')'+res['msg'])
def shell_copy(original, target):
"""
As shell copy.
"""
try:
if is_dir_existing(original):
shutil.copytree(original, target, symlinks=True)
else:
shutil.copy(original, target)
except Exception as e:
Logger.error("Error orccured: {}".format(str(e)))
return False
return True
def json_load(jsonFile):
"""
Convert json file to python data.
"""
if not is_file_existing(jsonFile):
Logger.error("Json file is not found: {}".format(jsonFile))
return None
with codecs.open(jsonFile, encoding="utf-8") as f:
try:
return json.load(f)
except Exception as e:
Logger.error("Json load failed: {}".format(str(e)))
return None
def run(self):
# init game state
previous_state = {
'game': GameControlData.STATE_INITIAL,
'time': time.time(),
'card': True
}
# run until canceled
while not self.__cancel.is_set():
try:
# wait 'till (re-)connected to network and gopro
if blackboard['network'] == 3:
self.connect()
# retrieve GameController data
self.gc_data = blackboard['gamecontroller']
# valid cam
if self.cam is not None:
# update internal cam status
if not self.updateStatus():
# disconnected?!?
self.disconnect()
# handling recording state
previous_state['game'] = self.handleRecording(
previous_state)
# take "keep alive" photo;
if self.take_photo_when_idle > 0 and self.take_photo_timestamp + self.take_photo_when_idle < time.time(
):
self.takePhoto()
# update sd-card status on the blackboard
if previous_state['card'] == True and self.cam_status[
'sd_card'] == False:
blackboard['gopro']['state'] = 3 # GoproNoSdcard
elif previous_state[
'card'] == False and self.cam_status[
'sd_card'] == True:
blackboard['gopro'][
'state'] = 2 # GoproSdcardInserted
previous_state['card'] = self.cam_status['sd_card']
else:
self.is_connected = False
else:
#
self.disconnect()
except Exception as ex:
# something unexpected happen!?
Logger.error(str(ex))
# if canceled, at least fire the disconnect event
self.disconnect()
logger.debug("GoPro thread finished.")
def download_file_by_url(url, saveAs):
"""
Download file by url.
"""
Logger.debug("Url to download: {}".format(url))
try:
resp = requests.get(url)
with open(saveAs, "wb") as f:
f.write(resp.content)
except Exception as e:
Logger.error("Error orrcured while downloading file:")
Logger.error(str(e))
return False
return True
def json_dumps(inputData):
"""
Dump json data.
"""
if isinstance(inputData, str):
return inputData
try:
formatedString = json.dumps(inputData,
indent = 4, sort_keys = True, ensure_ascii = False)
except Exception as e:
Logger.error("Json dump failed: {}".format(str(e)))
return None
return formatedString
def doAction(gpsFilePath):
Logger.debug("reading gps data from " + gpsFilePath)
gpsData = None
with open(gpsFilePath) as f:
gpsData = json.load(f)
if gpsData == None or gpsData["data"] == None:
Logger.error("No gps data found in " + gpsFilePath)
return
data = gpsData["data"]
distance = calcDistance(data)
Logger.debug("distance = " + str(distance) + " km")
return distance
def pyData_to_json_file(inputData, outputFile, appendFlag=False):
"""
Convert python data to json file.
"""
openMode = "w"
if appendFlag:
openMode = "a"
try:
with open(outputFile, openMode) as f:
f.write(json_dumps(inputData)+"\n")
except Exception as e:
Logger.error("Write data to json file failed: {}".format(str(e)))
return False
return True
def tar_xzf(tarFile, targetPath):
"""
Unackage files up like tar -xzf.
"""
if not is_file_existing(tarFile):
Logger.error("Unpackage tar file failed: file does not exist.")
return False
targetPath = get_abspath(targetPath)
try:
tarHandler = tarfile.open(tarFile)
tarHandler.extractall(path=targetPath)
tarHandler.close()
except Exception as e:
Logger.error("Unpackage tar file failed: " + str(e))
return False
return True
def main(argv):
parser = argparse.ArgumentParser(
description="Update wwe db with rosbag info files",
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('action',
help='\
action to perform.[all|single]\n\
all - to updated db with all info.json files found recursively in the given path.\n\
single - to update db with a single info json file.\n\
flush - removes all entries from the db.\n\
find - find and print details of the entry in db containing the provided filename.'
)
parser.add_argument(
'-d',
'--dataset_path',
help='path to wwe raw dataset dir to search for info.json files')
parser.add_argument(
'-i',
'--info',
help='info.json file whose content has to be added to the existing db')
parser.add_argument('-f', '--filename', help='filename to search in db')
parser.add_argument('-v',
'--verbose',
action='store_true',
help='enable verbose outputs')
args = parser.parse_args()
# Initialized logger
Logger.init(level=Logger.LEVEL_INFO, name="updateDB")
if args.verbose:
Logger.setLevel(Logger.LEVEL_DEBUG)
if args.action == 'all':
if args.dataset_path is not None:
update_all_info(args.dataset_path)
else:
Logger.error("Dataset path not provided!")
return
elif args.action == 'single':
if args.info is not None:
update_single_info(args.info)
else:
Logger.error("info.json file not provided to update db!")
return
elif args.action == "flush":
flushdb()
elif args.action == "find":
if args.filename is not None:
findFilename(args.filename)
else:
Logger.error("filename not provided to search db")
return
else:
Logger.error("unknown action - " + args.action)
def put_data():
#TODO: use TEST_CONFIG
t = int(time.time())
t_override = 1600419862
transactions = []
for i in range(10):
trans = Transaction(TransactionDateSec=t_override,
UUID='UUID-' + str(t + i),
UserId='UserId-1234',
AccountType='AccountType-checking',
Amount=1,
BankName='chase',
Description='Description-something',
TransactionType='TransactionType-debit')
transactions.append(trans)
put_response = put_transactions(transactions)
if put_response['FailedRecordCount'] != 0:
log.error("Failed to put record to Kinesis. Message: ")
else:
log.success("Successfully put data to Kinesis")
with open('config.json') as file:
config = json.load(file)
file.close()
try:
with open('C:\Windows\System32\drivers\etc\hosts') as file:
if "127.0.0.1 fuckrsvpkingz.adidas.co.uk" not in file.read():
with open('C:\Windows\System32\drivers\etc\hosts',
'a') as file:
file.write("\n\n# Adidas Account Generator")
file.write("\n127.0.0.1 fuckrsvpkingz.adidas.co.uk")
file.close()
else:
file.close()
except PermissionError:
logger.error(
"Failed to edit hosts file. Make sure to run as admin or edit hosts file manually."
)
input("")
sys.exit()
except:
logger.error(
"Failed to edit hosts file. Make sure to edit the hosts file manually before continuing if this has not been done already."
)
_thread.start_new_thread(app.run, ())
_thread.start_new_thread(manageTokens, ())
accountsList = []
creator = Generator(config['locale'],
'6LdyFRkUAAAAAF2YmQ9baZ6ytpVnbVSAymVpTXKi',
'https://www.adidas.com')
num = input("# ACCOUNTS: ")
webbrowser.open('http://fuckrsvpkingz.adidas.co.uk:5000/solve')
def run() -> None:
os.environ['TZ'] = 'Europe/Brussels'
if sys.platform != 'win32':
from time import tzset
tzset()
print(datetime.now())
load_dotenv()
Log.setup()
token = os.getenv('DISCORD_BOT_TOKEN')
assert token, "Could not find any dokbot bot token"
intents = discord.Intents.default()
intents.members = True
prefix = '>' if os.getenv('APP_ENV') == 'development' else '!'
bot = DokBot(command_prefix=prefix, intents=intents)
bot.add_cog(DokBotCog(bot))
bot.add_cog(EventCog(bot))
@bot.event
async def on_ready():
logging.getLogger().info(f'{bot.user.name} has connected.')
#
# @discord_client.event
# async def on_message(message: discord.Message) -> None:
# if not discord_client.is_ready() or message.author == discord_client.user:
# return
# try:
# await command_runner.run_command_for_message(message)
# except Exception as ex:
# await handle_exception(ex, author=message.author, content=message.content)
#
# @discord_client.event
# async def on_raw_reaction_add(reaction_event: discord.RawReactionActionEvent) -> None:
# if not discord_client.is_ready() or reaction_event.user_id == discord_client.user.id or reaction_event.emoji.name not in EMOJI_SIGNUP_STATUS.keys():
# return
# try:
# await signup_character(client=discord_client, reaction_event=reaction_event)
# except Exception as ex:
# user = await discord_client.fetch_user(reaction_event.user_id)
# await handle_exception(ex, author=user, content="Raid signup failed")
#
# async def handle_exception(ex: Exception, author: discord.User, content: str) -> None:
# Log.error(f"{author}, {content}, {ex}\n{traceback.format_exc()}")
# if isinstance(ex, BotException) and not isinstance(ex, InternalBotException):
# await author.send(ex.message)
# else:
# global maintainer
# if maintainer is None:
# maintainer = await discord_client.fetch_user(MAINTAINER_ID)
# await author.send(f"There were internal difficulties. Sending a message to {maintainer.display_name}")
# await maintainer.send(f'{author.display_name}, {content}, {ex}')
#
try:
bot.run(token)
except InvalidStatusCode as e:
error_message = f"Could not start client {e}\n{traceback.format_exc()}"
Log.error(error_message)
class TaskManager(object):
def __init__(self):
self.name = 'TaskManager'
self.logger = Logger(self.name)
self.tasks = []
self.priorities = []
def add_task(self, task):
curr_highest_priority = max(self.priorities) if self.priorities else 0
if task.priority < curr_highest_priority:
self.logger.warning(
(task.name,
'Request refused. Higher priority task is running.'))
return False
elif task.priority == curr_highest_priority:
self.logger.info((
task.name,
'Task is created successfully. Same priority task is running. Adding to the task list'
))
self.tasks.append(task)
self.priorities.append(task.priority)
elif task.priority > curr_highest_priority:
if self.tasks or self.priorities:
self.logger.warning(
(task.name,
'is created successfully. Other tasks are discarded.'))
self.tasks.clear()
self.priorities.clear()
self.tasks.append(task)
self.priorities.append(task.priority)
def clean_tasks(self):
"""
:brief: remove timeout and completed task from task list
:return:
"""
for task in list(self.tasks):
to_remove = False
if task.state == task.states['end']:
self.logger.info((task.name, 'is done.'))
to_remove = True
if task.is_current_task_timeout():
self.logger.error('Task ' + task.name + ' timeout...')
to_remove = True
if to_remove:
self.tasks.remove(task)
self.priorities.remove(task.priority)
def run_tasks(self):
self.clean_tasks()
for task in self.tasks:
self.logger.debug(('current task: ', task.name, 'current state: ',
task.state.name))
task.run()
async def process_failed(self, exception: Exception, event: Event):
if isinstance(exception, InvalidInputException):
return
Log.error(f"Failed to process {event} because of {exception}")
maintainer = await self.bot.fetch_user(MAINTAINER_ID)
await maintainer.send(f"Unexpected issue. {event}, {exception}")
class RTC(object):
def __init__(self, dev=None, enable_ems=False):
self.dev = dev
self.logger = Logger('RTC')
self.can_id = None # todo need to be further confirm
self.task = None
self.ui_queue = None
self.db = None
self.enable_ems = enable_ems
self.ems_data = Data() if self.enable_ems else None
self.scheduler = BackgroundScheduler(daemon=True)
self.set_scheduler()
def api(self, cmd, parameters):
self.logger.info('Real-Time Controller api() ' + ' ' + cmd + ' ' + json.dumps(parameters))
if cmd == 'TURN_OFF':
self.turn_off()
elif cmd == 'TURN_ON':
self.turn_on()
def contingency_analysis_classifier(self, can_message):
pass
def turn_off(self):
self.logger.info('TURNING OFF module')
def turn_on(self):
self.logger.info('TURNING ON module')
if self.task is None:
self.task = TurnOn(self, timeout=15)
else:
return False
def hi(self):
print(ctime(time()), end='\r', flush=True)
if self.task is not None:
self.task.state.spent_t += 0.5
self.task.spent_t += 0.5
self.task.run()
if self.task.spent_t > self.task.TIMEOUT:
self.logger.error('Task ' + self.task.name + ' fail...')
self.task = None
def get_ems_data(self):
results_dispatch = self.db.query(DispatchDBData).limit(2)
results_unit = self.db.query(UnitsDBData).limit(2)
results_forecast = self.db.query(ForecastDBData).limit(2)
# todo process every line of result and send to GUI
for d in results_dispatch:
res = d.__dict__
res.pop('_sa_instance_state')
res['datetime1'] = mktime(d.datetime1.timetuple()) + d.datetime1.microsecond / 1000000.0
self.ems_data.update(res)
self.ui_queue.put(self.ems_data)
def set_scheduler(self):
self.scheduler.add_job(self.hi, 'interval', seconds=0.5)
if self.enable_ems:
if self.db is None:
self.db = db_session()
self.scheduler.add_job(self.get_ems_data, 'interval', seconds=1)
self.scheduler.start()
def is_bic_online(self):
for dev in self.dev['bic']:
if not dev.is_connected():
self.logger.error((dev.name, ' is not online'))
return False
return True
def minimum_system_online(self):
for dev in self.dev['battery']:
if not dev.is_connected():
self.logger.error((dev.name, ' is not online'))
return False
for dev in self.dev['rm']:
if not dev.is_connected():
self.logger.error((dev.name, ' is not online'))
return False
return True
