import os
import math
import time
import pprint
from .robot_client import Robot
from .task import Task
from .network_proxy import NetworkProxy
from . import image
from lib.config import ConfigManager
from lib.logger_manager import LoggerManager
device_port_config = ConfigManager.get_device_port_config()
robot_config = ConfigManager.get_robot_config()
logger = LoggerManager.get_logger()
class Dodobot(Robot):
def __init__(self, session):
super(Dodobot, self).__init__(session)
self.gripper_state = {"recv_time": 0.0, "pos": 0}
self.brake_pedal_gripper_threshold = 0
self.prev_drive_command_time = 0.0
self.prev_drive_repeat_command_time = 0.0
self.prev_drive_repeat_stop_time = 0.0
self.prev_sent_command_time = 0.0
self.drive_command_timeout = robot_config.drive_command_timeout
self.drive_command_repeat_timeout = robot_config.drive_command_repeat_timeout
increase verbosity.',
action='count',
dest='verbose')
parser.add_argument('-V', '--version', help='Show version and exit', \
action='version', version=__VERSION__)
args = parser.parse_args()
# >> Global Argument parse & Build Conf<<
from lib.config import ConfigManager
import os
proj_path = os.path.dirname(os.path.realpath(__file__))
cfile = "{}/config/default.conf".format(proj_path)
cman = ConfigManager.load(cfile)
cman.set('project_path', proj_path)
def filetoList(lfile, emsg):
lst = []
if os.path.exists(lfile) and os.path.isfile(lfile):
with open(lfile, 'r') as f:
for l in f:
lst.append(l)
return lst
else:
raise Exception(emsg)
def _load_conf(self):
conf.load('./f0x.config')
if self.is_verbose():
pp.p_debug("Loaded Config file, keys: {}".format(
self.get_conf().getKeys()))
def get_conf(self):
return conf.getConfig()
import time
import array
import queue
import struct
import select
import threading
from fcntl import ioctl
from lib.logger_manager import LoggerManager
from lib.config import ConfigManager
from .node import Node
logger = LoggerManager.get_logger()
joystick_config = ConfigManager.get_joystick_config()
axis_names = {
0x00: 'x',
0x01: 'y',
0x02: 'z',
0x03: 'rx',
0x04: 'ry',
0x05: 'rz',
0x06: 'trottle',
0x07: 'rudder',
0x08: 'wheel',
0x09: 'gas',
0x0a: 'brake',
0x10: 'hat0x',
0x11: 'hat0y',
import time
import datetime
import threading
import numpy as np
from . import tof_obstacles
from .device_port import DevicePort, DevicePortReadException, DevicePortWriteException
from lib.config import ConfigManager
from lib.logger_manager import LoggerManager
from .packet import Packet
from lib.exceptions import ShutdownException, LowBatteryException
from ..node import Node
rover_config = ConfigManager.get_rover_config()
device_port_config = ConfigManager.get_device_port_config()
battery_config = ConfigManager.get_battery_config()
logger = LoggerManager.get_logger()
class BatteryState:
UNKNOWN = 0
FULL = 1
OK = 2
LOW = 3
CRITICAL = 4
def __init__(self):
self.state = 0
self.voltage_V = 0.0
self.prev_critical_time = None
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from lib.config import ConfigManager
from lib.singleton import Singleton
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import smtplib
from django.core.mail import send_mail
config = ConfigManager.instance()
@Singleton
class SmtpEmailHelper(object):
"""
This class will send emails, using the credentials in tasknode/tasknode.cfg
"""
def __init__(self):
self.smtp_username = config.smtp_username
self.smtp_password = config.smtp_password
self.smtp_host = config.smtp_endpoint
def create_plain_message(self, template_name, template_data):
"""
This will create a plain text email using the provided template_name and data
:param template_name: The template to populate
:param template_data: The data to use to populate
:return: A string represtation of the plain text email
"""
template = open('lib/smtp/email_templates/' + template_name + '.txt')
content = template.read()
from pydub import generators
from lib.config import ConfigManager
from lib.logger_manager import LoggerManager
from .pulseaudio import Audio, Pacmd
from ..node import Node
sound_config = ConfigManager.get_sounds_config()
logger = LoggerManager.get_logger()
class Sounds(Node):
def __init__(self, session):
super(Sounds, self).__init__(session)
self.controller = Pacmd(
sound_config.audio_sink,
sound_config.volume_raw_min,
sound_config.volume_raw_max,
)
self.sounds = {}
self.load_audio(sound_config.sounds)
def start(self):
self.controller.set_volume(sound_config.volume)
def stop(self):
for audio in self.sounds.values():
audio.unload()
print("Test 1: check if Firefox, Geckodrive and Selenium are installed ok")
web_crawler = BrowserCrawler()
print("Try to load Dantri")
web_crawler.load_page("https://dantri.com.vn")
title = web_crawler.get_title()
print("title: %s" % title)
if title is not None:
print("Result: OK")
else:
print("Result: FAIL")
print()
web_crawler.quit()
# Test 2: Check if config file is existed and can be parsed
print("Test 2: check if config file can be parsed")
base_dir = os.environ['DOCBAO_BASE_DIR']
config_file = get_independent_os_path(
[base_dir, "src", "backend", "input", "config.yaml"])
config_manager = ConfigManager(config_file)
config_manager.load_data()
if len(config_manager.get_newspaper_list()) >= 0:
print("Result: OK")
else:
print("Result: FAIL")
print()
import time
from lib.config import ConfigManager
from lib.logger_manager import LoggerManager
battery_config = ConfigManager.get_battery_config()
logger = LoggerManager.get_logger()
class BatteryState:
UNKNOWN = 0
FULL = 1
OK = 2
LOW = 3
CRITICAL = 4
def __init__(self):
self.state = 0
self.recv_time = 0.0
self.current_mA = 0.0
self.power_mW = 0.0
self.voltage_V = 0.0
self.prev_critical_time = None
self.prev_V = 0.0
def update_state(self, power_state):
self.recv_time = power_state["recv_time"]
self.current_mA = power_state["current_mA"]
self.power_mW = power_state["power_mW"]
self.voltage_V = power_state["load_voltage_V"]
from server.modules.copter_table_models import CopterDataModel
config_path = 'temp_config/config'
spec_path = os.path.join(config_path, 'spec')
if not os.path.exists(spec_path):
try:
os.makedirs(spec_path)
except OSError:
print("Creation of the directory {} failed".format(spec_path))
else:
print("Successfully created the directory {}".format(spec_path))
shutil.copy("Server/config/spec/configspec_server.ini", spec_path)
config = ConfigManager()
config.load_config_and_spec(os.path.join(config_path,' server.ini'))
preset_params = config.table_presets_default
default_param = (True, 100)
default = {key: f"preset_param(default=list{preset_params.get(key, default_param)})"
for key in CopterDataModel.columns}
cfg_server = ConfigObj('Server/config/spec/configspec_server.ini', list_values=False)
cfg_server['TABLE']['PRESETS']['DEFAULT'] = default
cfg_server.write()
print('Server configspec updated!')
shutil.rmtree('temp_config')
# * if needed to run seperately
if __name__ == "__main__":
import sys
import os
proj_path = os.path.realpath("{}/../".format(os.path.dirname(os.path\
.realpath(__file__))))
sys.path.insert(0, proj_path)
from lib.config import ConfigManager
cman = ConfigManager.load("{}/config/default.conf".format(proj_path))
cman.set('project_path', proj_path)
from lib.modules import BaseModule
import argparse
# * Module class name must be the same as of file name
class example(BaseModule):
"""
* An example class for defining module
*
* only 3 methods are necessary to define.
* `__init__(**kwargs)` with call to super with passing the `**kwargs`
* `defineArgs()` to define modules related arguments
* `main()` to be able to call from parent class
"""
__KEYWORDS__ = ['example module', 'training', 'tutorial']
def __init__(self, **kwargs):
# * to pass global arguments to BaseModule
import time
from lib.config import ConfigManager
rover_config = ConfigManager.get_rover_config()
def get_checksum(b: bytes):
checksum = 0
for val in b:
checksum += val
checksum &= 0xff
return checksum
class Packet:
PACKET_CODES = rover_config.packet_codes
WRITE_COMMANDS = rover_config.write_commands
WRITE_CODES = rover_config.write_codes
SEGMENT_DELIMITER = b"\t"
PACKET_START = b"\x12\x34"
PACKET_STOP = b"\n"
CODE_TO_TYPE = {
'd': int,
'l': int,
'f': float,
's': str,
}
import yaml, json
from lib.filemanager import FileManager
from lib.polling import PollingManager
from lib.ip_webcam import IPWebcam
from lib.config import ConfigManager
from utils.surveillance_web_server import set_filemanager, run
## test
if __name__ == "__main__":
cm = ConfigManager()
configs = cm.get_configs()
fm = FileManager(configs["record_path"])
fm.set_max_days_age(1)
fm.start_rotate_thread()
set_filemanager(fm)
for stream in config["streams"]:
host, port = stream["source"].split(":")
cam = IPWebcam(host, port)
pm = PollingManager()
pm.set_device(cam)
pm.set_filemanager(fm)
pm.set_prefix(stream["name"])
pm.start_polling()
run()
import os
import sys
import time
import subprocess
from lib import arguments
arguments.init() # initialize ConfigManager and LoggerManager
from lib.config import ConfigManager
from lib.logger_manager import LoggerManager
from lib.exceptions import *
from lib.session import Session
logger = LoggerManager.get_logger()
general_config = ConfigManager.get_general_config()
def shutdown(session):
logger.warn("Shutdown function called. Shutting down everything.")
session.stop()
subprocess.call("sudo shutdown -h now", shell=True)
def reboot(session):
logger.warn("Reboot function called. Shutting down everything.")
session.stop()
subprocess.call("sudo reboot now", shell=True)
def relaunch(session):
import re
import time
import logging
import subprocess
from logging import handlers
from lib.config import ConfigManager
from lib.logger_manager import MyFormatter
from .node import Node
data_log_config = ConfigManager.get_data_log_config()
class DataLogger(Node):
start_flag = "---- Data Logger start -----"
def __init__(self, master):
self.logger = self._create_logger(**data_log_config.to_dict())
self.cpu_temp_regex = r"temp=([\d.]*)'C"
self.prev_log_time = time.time()
self.log_timeout = 1.0 / data_log_config.log_freq_hz
self.logger.info(self.start_flag)
super(DataLogger, self).__init__(master)
def update(self):
if time.time() - self.prev_log_time < self.log_timeout:
return
self.prev_log_time = time.time()
def __init__(self, **kwargs):
if 'conf' in kwargs.keys():
self.conf = kwargs['conf']
else:
from lib.config import ConfigManager
self.conf = ConfigManager.getConfig()