def create_sync(self):
"""
creates a sync object.
"""
if self.certificate_file is None:
self.sync = Sync(self.server_address, self.username, self.password)
else:
self.sync = Sync(self.server_address, self.username, self.password,
self.certificate_file.name)
def onLogin(self, host, username, passwd, ssl):
"""
Slot. Triggers a log in request to the server.
:param host: Indicates the hostname of the FTP server
:param username: Username to log in into the FTP server
:param passwd: Password to log in into the FTP server
:param ssl: Indicates whether the FTP needs SSL support
"""
self.sync = Sync(host, ssl)
self.syncStarted.connect(self.sync.initQueue)
self.sync.server.downloadProgress.connect(self.onDownloadProgress)
self.sync.server.uploadProgress.connect(self.onUploadProgress)
self.sync.server.fileEvent.connect(self.onFileEvent)
self.sync.server.badFilenameFound.connect(self.badNameWarning)
self.sync.server.loginCompleted.connect(self.onLoginCompleted)
self.sync.server.fileEventCompleted.connect(self.onFileEventCompleted)
self.sync.server.ioError.connect(self.onIOError)
# Added by Si
self.sync.server.textStatus.connect(self.setStatus)
self.sync.statusChanged.connect(self.setStatus)
self.loginRequested.connect(self.sync.server.onLogin)
self.syncThread = QThread()
self.sync.moveToThread(self.syncThread)
self.syncThread.start()
QApplication.instance().lastWindowClosed.connect(self.syncThread.quit)
self.loginRequested.emit(username, passwd)
def __init__(self, config=None):
if config is None:
config = get_config_from_file("config.ini")
self.config = config
# Seed the trust stores
Sync(self.config).seed()
self.cert_processor = CertProcessor(config)
def run(self):
sync = Sync(show_progress=self._isManual, run_silent=self._runSilent, library=self._library, api=globals.traktapi)
sync.sync()
if utilities.getSettingAsBool('tagging_enable') and utilities.getSettingAsBool('tagging_tag_after_sync'):
q = queue.SqliteQueue()
q.append({'action': 'updatetags'})
def main():
"""Main
"""
start = time()
parser = ArgumentParser(description='Sync', prog='python __main__.py')
add = parser.add_argument
add('--clean', action='store_true', help='delete all .gz files')
add('--console-debug', nargs='?', default='INFO', help='console debug level',
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
add('--download', action='store_true', help='download JSON files')
add('--host', nargs='?', default='/', help='host, ex: /seriv/')
add('--no-debug', nargs='?', default=0, const=1, type=int, help="remove debug code from the javascript")
add('--no-process', nargs='?', default=0, const=1, type=int, help="don't process the images")
add('--zip', action='store_true', help='create .gz files')
args = parser.parse_args()
args_dict = vars(args)
if args.download:
download_json()
else:
sync = Sync(**args_dict)
sync.synchronise()
end = time()
print(f'\nELAPSED: {end-start:.3f} seconds')
def op_sync (self):
conf = self.get_config()
pname = self._load_profile()
sync = Sync(conf, pname, self.get_db(), dr=self.is_dry_run())
if self.is_dry_run():
sync.prep_lists(self.get_sync_dir())
else:
try:
startt = conf.get_curr_time()
result = sync.sync(self.get_sync_dir())
if result:
conf.set_last_sync_start(pname, val=startt)
conf.set_last_sync_stop(pname)
logging.info('Updating item inventory...')
sync.save_item_lists()
logging.info('Updating item inventory...done')
else:
logging.info('timestamps not reset for profile %s due to '
'errors (previously identified).', pname)
except Exception, e:
logging.critical('Exception (%s) while syncing profile %s',
str(e), pname)
logging.critical(traceback.format_exc())
return False
def _get_sync_object():
""" get sync object """
try:
sync = Sync()
sync.bucket = args.bucket
return sync
except NoCredentialsError as ex:
log.debug('Error to connect to Amazon. Can not found the credentials.')
log.debug(repr(ex))
log.debug('Exit')
exit(1)
def run(self):
"""
Thread: Run
"""
s = Sync(self.src, self.dst, **self.kwargs)
s.diff()
self.loadInitContents(s)
s.progressfnc = self.progress
while True:
s.diff()
s.difftrim(create=self.getInitContents())
s.run()
time.sleep(self.freq)
def main():
global sync
print(sys.argv)
url = "index.html"
if len(sys.argv) > 1:
url = sys.argv[1]
print("main thread id:", threading.get_ident())
data_dir = appdirs.user_data_dir(APPNAME)
if not os.path.exists(data_dir):
os.mkdir(data_dir)
setting = read_setting_db()
if not setting:
setting = {
"workspace": os.path.join(Path.home(), "gitCloud"),
"interval": config.SYNC_INTERVAL
}
print("setting:", setting)
excludesFile = os.path.join(appdirs.user_data_dir(APPNAME), ".gitignore")
createExcludesFile(excludesFile)
print("excludesFile:", excludesFile)
workspace = setting["workspace"]
if not os.path.exists(workspace):
os.mkdir(workspace)
if os.path.isabs(config.GIT):
path = os.path.dirname(config.GIT)
env_path = os.getenv("PATH")
if env_path:
env_path = env_path + ":" + path
else:
env_path = path
set_env_path(env_path)
api = Api(setting)
repos = [repo.copy() for repo in api.repos]
sync = Sync(repos, event_q, setting["interval"], excludesFile)
window = webview.create_window('gitCloud',
url,
width=400,
height=680,
js_api=api)
api.window = window
api.start()
sync.start(sync_q, workspace)
webview.start(debug=config.DEBUG)
def syncElement(self,
path,
filename,
extension,
imdbid,
istvshow,
oldelement=None):
printl(
str(path) + " " + str(filename) + " " + str(extension) + " " +
str(imdbid) + " " + str(istvshow), self)
element = None
if oldelement is None:
element = MediaInfo(path, filename, extension)
element.parse()
element.ImdbId = imdbid
else:
element = oldelement #.copy()
if istvshow:
element.setMediaType(MediaInfo.SERIE)
else:
element.setMediaType(MediaInfo.MOVIE)
results = Sync().syncWithId(element)
if results is not None:
return results
else:
if istvshow is False:
element.setMediaType(MediaInfo.SERIE)
else:
element.setMediaType(MediaInfo.MOVIE)
results = Sync().syncWithId(element)
if results is not None:
return results
return None
def updateAll(self,
notifyOutput=None,
notifyProgress=None,
notifyRange=None):
episodes = self.getAll(self.TVSHOWSEPISODES)
total = len(episodes)
progress = 0
if notifyRange is not None:
notifyRange(total)
if notifyProgress is not None:
notifyProgress(0)
for episode in episodes:
if episode.Title is None or episode.Season is None or episode.Episode is None:
continue
tvshow = self.getMedia(episode.ParentId)
if episode.Title == tvshow.Title:
printl(
"Episode has same title as tvshow so probably update needed (%s %dx%d)"
% (episode.Title, episode.Season, episode.Episode), self,
"I")
if notifyOutput is not None:
notifyOutput(
Utf8.utf8ToLatin(
"Updating %s %dx%d" %
(episode.Title, episode.Season, episode.Episode)))
id = episode.Id
seen = self.isMediaSeen(episode.Id)
episode.setMediaType(episode.SERIE)
newElement = Sync().syncWithId(episode)
if newElement is not None:
if len(newElement) == 2:
episode = newElement[1]
else:
episode = newElement[0]
self.deleteMedia(id)
ret = self.insertMedia(episode)
if seen:
self.MarkAsSeen(ret["id"])
progress = progress + 1
printl(
"Update progress %.2f (%d/%d)" %
((progress / total) * 100.0, progress, total), self, "I")
if notifyProgress is not None:
notifyProgress(progress)
notifyProgress(total)
def op_sync(self):
conf = self.get_config()
pname = self._load_profile()
startt_old = conf.get_last_sync_start(pname)
stopt_old = conf.get_last_sync_stop(pname)
if self.is_sync_all():
# This is the case the user wants to force a sync ignoring the
# earlier sync states. This is useful when ASynK code changes -
# and let's say we add support for synching a enw field, or some
# such.
#
# This works by briefly resetting the last sync start and stop
# times to fool the system. If the user is doing a dry run, we
# will restore his earlier times dutifully.
if self.is_dry_run():
logging.debug('Temporarily resetting last sync times...')
conf.set_last_sync_start(pname, val="1980-01-01T00:00:00.00+00:00")
conf.set_last_sync_stop(pname, val="1980-01-01T00:00:00.00+00:00")
sync = Sync(conf, pname, self.get_db(), dr=self.is_dry_run())
if self.is_dry_run():
sync.prep_lists(self.get_sync_dir())
# Since it is only a dry run, resetting to the timestamps to the
# real older sync is sort of called for.
conf.set_last_sync_start(pname, val=startt_old)
conf.set_last_sync_stop(pname, val=stopt_old)
logging.debug('Reset last sync timestamps to real values')
else:
try:
startt = conf.get_curr_time()
result = sync.sync(self.get_sync_dir())
if result:
conf.set_last_sync_start(pname, val=startt)
conf.set_last_sync_stop(pname)
logging.info('Updating item inventory...')
sync.save_item_lists()
logging.info('Updating item inventory...done')
else:
logging.info(
'timestamps not reset for profile %s due to '
'errors (previously identified).', pname)
except Exception, e:
logging.critical('Exception (%s) while syncing profile %s',
str(e), pname)
logging.critical(traceback.format_exc())
return False
def __init__(self, port, virtual_world, camera_mgr, sync_session):
self.port = port
self.virtual_world = virtual_world
self.cam_mgr = camera_mgr
self.task_mgr = virtual_world.taskMgr
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cReader.setRawMode(True)
self.cWriter = ConnectionWriter(self.cManager, 1)
self.cWriter.setRawMode(True)
self.tcpSocket = self.cManager.openTCPServerRendezvous(port, BACKLOG)
self.cListener.addConnection(self.tcpSocket)
self.activeSessions = {}
self.connection_map = {}
self.set_handlers()
hostname = socket.gethostname()
a, b, address_list = socket.gethostbyname_ex(hostname)
self.ip = address_list[0]
logging.info("Addresses %s" % address_list)
logging.info("Server is running on ip: %s, port: %s" %
(self.ip, self.port))
self.client_counter = 0
self.read_buffer = ''
self.read_state = 0
self.read_body_length = 0
self.packet = SocketPacket()
controller = virtual_world.getController()
self.sync = Sync(self.task_mgr, controller, camera_mgr, sync_session)
self.vv_id = None
if sync_session:
logging.info("Waiting for Sync Client!")
self.showing_info = False
virtual_world.accept("i", self.toggleInfo)
self.sync_session = sync_session
self.createInfoLabel()
atexit.register(self.exit)
def main():
patch_win_unicode()
try:
config = Config()
config.read()
src_storage = _get_storage(config, config.src)
if config.list_only or config.list_folders:
walker = _get_walker(config, src_storage, config.list_format)
walker.walk()
else:
dest_storage = _get_storage(config, config.dest)
sync = Sync(config, src_storage, dest_storage)
sync.run()
except urllib2.URLError as e:
logger.error("Error connecting to server. {!r}".format(e))
sys.exit(1)
except KeyboardInterrupt:
sys.exit()
async def run():
async def face_loop():
nonlocal face, running
while running:
face.processEvents()
await asyncio.sleep(0.01)
event_loop = asyncio.get_event_loop()
event_loop.create_task(face_loop())
running = True
face = Face()
keychain = KeyChain()
face.setCommandSigningInfo(keychain, keychain.getDefaultCertificateName())
sync = Sync(prefix=Name("/git"), face=face, on_update=on_update)
sync.run()
while True:
await sync.publish_data(branch="test_branch", timestamp=None)
await asyncio.sleep(5)
def __init__(self):
parser = ArgumentParser()
parser.add_argument('-c')
args = parser.parse_args()
if not os.path.exists(args.c):
raise Exception('Error while reading config')
config = ConfigParser()
config.read(args.c)
fileConfig(args.c)
self.Logger = getLogger(__name__)
self.client = Sync(config)
self.to_get_queue = gevent.queue.Queue(maxsize=500)
self.to_put_queue = gevent.queue.Queue(maxsize=500)
db_url = create_db_url(
config.get('user', 'username'),
config.get('user', 'password'),
config.get('db', 'host'),
config.get('db', 'port'),
)
self.get_db(db_url, config.get('db', 'name'))
def prepare_sync(key: bytes, app_id: int, installation_id: int) -> Sync:
gh = GitHub()
gh.login_as_app_installation(key, app_id, installation_id)
auth = "x-access-token:" + gh.session.auth.token
repos = {}
print(f"Checking GitHub repositories for installation {installation_id}")
for r in _app_installation_repositories(gh):
if not r.homepage:
print(f"NOTE: Skipping repository {r.full_name} (no homepage)")
continue
assert r.name not in repos, 'Duplicate repository name: ' + r.name
# FIXME: Should we always append .git?
src = parse_url(r.homepage + ".git")
dest = parse_url(r.clone_url)._replace(auth=auth)
repos[r.name] = Repo(src, dest)
return Sync(repos)
def start(self):
"""
Starts an experiment.
"""
print("Starting experiment...")
self.sync = Sync(
device=self.attr_device,
counter_input=self.attr_counter_input,
counter_output=self.attr_counter_output,
counter_bits=self.attr_counter_bits,
event_bits=self.attr_event_bits,
output_path=self.attr_output_path,
freq=self.attr_pulse_freq,
verbose=True,
force_sync_callback=False,
)
lines = eval(self.attr_line_labels)
for index, line in enumerate(lines):
self.sync.add_label(index, line)
self.sync.start()
from config import ConfigLoader
from sync import Sync
from util import read_file
from worker import Worker
# Load all properties from INI and point to the folder where resources are stored
props_file = "app.ini"
cl = ConfigLoader.load(props_file, 'sync_resource')
# Just for process output
with open("logging.yml") as log_cfg:
logging.config.dictConfig(yaml.safe_load(log_cfg))
sync_options = cl.get_config('sync')
resources_config = cl.get_resource_config()
log_folder = sync_options.get("log_folder")
os.makedirs(log_folder, exist_ok=True)
# The "base" config into which sync config gets merged
template_config = resources_config.merge_with(sync_options.values)
template_config.set_value("log_folder", os.path.abspath(log_folder))
# Read in the set of example syncs
example_sync_data = read_file("../example_sync/example.yml")
# Execute (single thread for now)
for config in example_sync_data:
sync = Sync(config)
w = Worker(sync, template_config)
w.run()
def run(self):
sync = Sync(show_progress=self._isManual,
run_silent=self._runSilent,
library=self._library,
api=globals.traktapi)
sync.sync()
from sync import Sync
import logger
INVALID_FILENAME_CHARS = '\/:*?"<>|'
STRIPTAGS = re.compile(r'<[^>]+>')
STRIPHEAD = re.compile("<head>.*?</head>", re.DOTALL)
EMPTYP = re.compile('<p style=\"-qt-paragraph-type:empty;.*(?=<p>)', re.DOTALL)
NOTESPATH = os.path.expanduser('~/.ownnotes/')
COLOR_TITLE = '#441144'
COLOR_LINK = '#115511'
COLOR_SUBTITLE = '#663366'
settings = Settings()
sync = Sync()
if not os.path.exists(NOTESPATH):
os.makedirs(NOTESPATH)
def _getValidFilename(filepath):
dirname, filename = os.path.dirname(filepath), os.path.basename(filepath)
return os.path.join(dirname, ''.join(car for car in filename
if car not in INVALID_FILENAME_CHARS))
def setColors(title_color, subtitle_color, link_color):
global COLOR_TITLE
global COLOR_LINK
global COLOR_SUBTITLE
def main():
parser = argparse.ArgumentParser(
description='Sync current folder to your flickr account.')
parser.add_argument('--monitor',
action='store_true',
help='Start monitoring daemon.')
parser.add_argument(
'--starts-with',
type=str,
help='Only sync those paths that start with this text, e.g. "2015/06."'
)
parser.add_argument(
'--download',
type=str,
help='Download photos from flickr. Specify a path or use "." for all.')
parser.add_argument('--dry-run',
action='store_true',
help='Do not download or upload anything.')
parser.add_argument('--ignore-videos',
action='store_true',
help='Ignore video files.')
parser.add_argument('--ignore-images',
action='store_true',
help='Ignore image files.')
parser.add_argument(
'--ignore-ext',
type=str,
help=
'Comma separated list of filename extensions to ignore, e.g. "jpg,png".'
)
parser.add_argument('--fix-missing-description',
action='store_true',
help='Replace missing set description with set title.')
parser.add_argument('--version',
action='store_true',
help='Output current version: ' + version)
parser.add_argument('--sync-path',
type=str,
default=os.getcwd(),
help='Specify sync path (default: current dir).')
parser.add_argument(
'--sync-from',
type=str,
help=
'Only one supported value: "all". Upload anything not on flickr. Download anything not on the local filesystem.'
)
parser.add_argument(
'--custom-set',
type=str,
help='Customize set name from path with regex, e.g. "(.*)/(.*)".')
parser.add_argument(
'--custom-set-builder',
type=str,
help=
'Build custom set title, e.g. "{0} {1}" joins first two groups (default behavior merges groups using a hyphen).'
)
parser.add_argument(
'--update-custom-set',
action='store_true',
help=
'Updates set title from custom-set (and custom-set-builder, if given).'
)
parser.add_argument(
'--custom-set-debug',
action='store_true',
help=
'When testing custom sets: ask for confirmation before creating an album.'
)
parser.add_argument('--username',
type=str,
help='Token username argument for API.')
parser.add_argument('--keyword',
action='append',
type=str,
help='Only upload files matching this keyword.')
args = parser.parse_args()
if args.version:
logger.info(version)
exit()
# Windows OS
args.is_windows = os.name == 'nt'
args.sync_path = args.sync_path.rstrip(os.sep) + os.sep
if not os.path.exists(args.sync_path):
logger.error('Sync path does not exist.')
exit(0)
local = Local(args)
remote = Remote(args)
sync = Sync(args, local, remote)
sync.start_sync()
def __init__(self, options):
super(DriverWindow, self).__init__()
#uic.loadUi('ui/driverGUI.ui', self)
self.options = options
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.tabWidget.setCurrentIndex(0)
self.resetInfo(initial=True)
self.ui.labelTest = {
"MS5611": self.ui.label_baroTest,
"MPU6050": self.ui.label_MPUTest,
"HMC5883L": self.ui.label_magTest
}
self.state = STATE.DISCONNECTED
# ROS
self.d = Dialog(options)
self.ros = ROSNode(options, self)
# FLIE
self.flie = FlieControl(self)
self.ui.checkBox_pktHZ.toggled.connect(
lambda on: self.flie.setPacketUpdateSpeed(self.ui.spinBox_pktHZ.
value() if on else 0))
self.ui.spinBox_pktHZ.valueChanged.connect(self.flie.inKBPS.setHZ)
self.ui.spinBox_pktHZ.valueChanged.connect(self.flie.outKBPS.setHZ)
self.ui.spinBox_pktHZ.valueChanged.emit(
self.ui.spinBox_pktHZ.value()) # force update
self.ui.checkBox_kill.toggled.connect(self.flie.setKillswitch)
self.flie.setKillswitch(self.ui.checkBox_kill.isChecked())
self.ui.checkBox_xmode.toggled.connect(
self.flie.crazyflie.commander.set_client_xmode)
self.flie.crazyflie.commander.set_client_xmode(
self.ui.checkBox_xmode.isChecked())
# Set up ParamManager
self.paramManager = ParamManager(self.flie.crazyflie, self)
self.ui.tab_param.layout().addWidget(self.paramManager)
# Set up LogManager
self.logManager = LogManager(self.flie.crazyflie, self)
self.ui.tab_log.layout().addWidget(self.logManager)
self.ui.checkBox_logHZ.toggled.connect(self.logManager.setEstimateHzOn)
self.ui.spinBox_logHZ.valueChanged.connect(
self.logManager.setFreqMonitorFreq)
self.logManager.sig_rosData.connect(self.ros.receiveCrazyflieLog)
self.autoRetryTimer = QTimer()
self.autoRetryTimer.setInterval(1500)
self.autoRetryTimer.timeout.connect(lambda: self.connectPressed(
self.ui.comboBox_connect.currentText(), auto=True))
self.autoRetryTimer.setSingleShot(True)
# Set up TrackManager
self.trackManager = TrackManager(self.ros.sub_tf, self.ros.pub_tf,
self)
self.ui.tab_tracking.layout().addWidget(self.trackManager)
# AI
self.ai = AttitudeIndicator(self.ui.tab_hud)
self.logManager.sig_rpy.connect(self.ai.setRollPitchYaw)
self.ui.tab_hud.layout().addWidget(self.ai)
self.ui.checkBox_AI.stateChanged.connect(self.ai.setUpdatesEnabled)
self.ui.spinBox_AIHZ.valueChanged.connect(self.ai.setUpdateSpeed)
self.logManager.sig_hoverTarget.connect(self.ai.setHover)
self.logManager.sig_baroASL.connect(self.ai.setBaro)
self.logManager.sig_accZ.connect(self.ai.setAccZ)
self.logManager.sig_motors.connect(self.ai.setMotors)
self.logManager.sig_batteryUpdated.connect(self.ai.setBattery)
self.logManager.sig_batteryState.connect(self.ai.setPower)
self.logManager.sig_temp.connect(self.ai.setTemp)
self.logManager.sig_cpuUpdated.connect(self.ai.setCPU)
self.logManager.sig_pressure.connect(self.ai.setPressure)
self.logManager.sig_aslLong.connect(self.ai.setAslLong)
self.paramManager.sig_gyroCalib.connect(self.ai.setCalib)
self.flie.inKBPS.sig_KBPS.connect(self.ai.setPktsIn)
self.flie.outKBPS.sig_KBPS.connect(self.ai.setPktsOut)
self.flie.sig_flieLink.connect(self.ai.setLinkQuality)
self.flie.sig_stateUpdate.connect(self.ai.setFlieState)
self.ui.checkBox_reconnect.stateChanged.connect(
self.ai.setAutoReconnect)
self.logManager.sig_hzMeasure.connect(self.ai.updateHz)
self.logManager.sig_logStatus.connect(self.ai.updateHzTarget)
# Yaw offset
self.ui.doubleSpinBox_yaw.valueChanged.connect(
lambda yaw: self.ui.horizontalSlider_yaw.setValue(yaw * 10))
self.ui.horizontalSlider_yaw.valueChanged.connect(
lambda yaw: self.ui.doubleSpinBox_yaw.setValue(yaw / 10))
self.ui.doubleSpinBox_yaw.valueChanged.connect(
self.logManager.setYawOffset)
self.ui.checkBox_yaw.stateChanged.connect(
lambda x: self.logManager.setYawOffset(self.ui.doubleSpinBox_yaw.
value() if x else 0))
self.ui.checkBox_yaw.stateChanged.emit(
self.ui.checkBox_yaw.checkState()) # force update
self.ui.pushButton_north.clicked.connect(
lambda: self.ui.doubleSpinBox_yaw.setValue(self.logManager.getYaw(
)))
# ASL offset
self.ui.doubleSpinBox_ground.valueChanged.connect(
self.logManager.setGroundLevel)
self.ui.checkBox_ground.stateChanged.connect(
lambda x: self.logManager.setGroundLevel(
self.ui.doubleSpinBox_ground.value() if x else 0))
self.ui.checkBox_ground.stateChanged.emit(
self.ui.checkBox_ground.checkState())
self.ui.pushButton_ground.clicked.connect(
lambda: self.ui.doubleSpinBox_ground.setValue(self.logManager.
getASL()))
self.ros.sig_baro.connect(self.logManager.setAslOffset)
# init previous settings
self.readSettings()
# Sync
self.sync = Sync(self.flie.crazyflie)
self.sync.sig_delayUp.connect(
lambda x: self.ui.label_up.setText(str(round(x, 2)) + "ms"))
self.sync.sig_delayDown.connect(
lambda x: self.ui.label_down.setText(str(round(x, 2)) + "ms"))
self.ui.groupBox_sync.toggled.connect(self.sync.enable)
self.ui.spinBox_syncHz.valueChanged.connect(self.sync.setSyncRate)
self.ui.spinBox_syncHz.valueChanged.emit(
self.ui.spinBox_syncHz.value())
self.ui.groupBox_sync.toggled.emit(self.ui.groupBox_sync.isChecked())
self.sync.sig_cpuTime.connect(
lambda x: self.ui.label_cputime.setText("%08.03fs" % x))
self.sync.sig_flieTime.connect(
lambda x: self.ui.label_flietime.setText("%08.03fs" % x))
self.sync.sig_diffTime.connect(
lambda x: self.ui.label_difftime.setText("%08.03fs" % x))
self.ui.checkBox_rosLog.stateChanged.connect(
self.logManager.setPubToRos)
self.ui.groupBox_ros.clicked.connect(
lambda x: self.logManager.setPubToRos(
min(self.ui.groupBox_ros.isChecked(),
self.ui.checkBox_rosLog.checkState()))) #
# Updating the GUI (if we didnt do this, every change would result in an update...)
self.guiUpdateQueue = {}
self.guiUpdateQueueSave = 0
self.guiUpdateTimer = QTimer()
self.guiUpdateTimer.setInterval(1000 / self.ui.spinBox_guiHZ.value())
self.ui.spinBox_guiHZ.valueChanged.connect(
lambda x: self.guiUpdateTimer.setInterval(1000 / x))
self.guiUpdateTimer.timeout.connect(self.updateGui)
self.guiUpdateTimer.start()
# Defaults according to settings within GUI
self.beepOn = self.ui.checkBox_beep.isChecked()
self.killOn = self.ui.checkBox_kill.isChecked()
self.autoReconnectOn = self.ui.checkBox_reconnect.isChecked()
self.startupConnectOn = self.ui.checkBox_startupConnect.isChecked()
self.ui.groupBox_input.toggled.connect(
lambda x: self.ros.sig_joydata.connect(self.setInputJoy)
if x else self.ros.sig_joydata.disconnect(self.setInputJoy))
if self.ui.groupBox_input.isChecked():
self.ros.sig_joydata.connect(self.setInputJoy)
# Set up URI scanner
self.scanner = ScannerThread(radio=options.radio)
self.scanner.start()
# Connections from GUI
self.ui.pushButton_connect.clicked.connect(
lambda: self.connectPressed(self.ui.comboBox_connect.currentText(),
auto=False)) # Start button -> connect
self.ui.comboBox_connect.currentIndexChanged.connect(self.uriSelected)
self.ui.checkBox_beep.toggled.connect(self.setBeep)
self.ui.checkBox_kill.toggled.connect(self.setKill)
self.ui.checkBox_kill.toggled.connect(self.ai.setKillSwitch)
self.ui.checkBox_kill.toggled.emit(
self.ui.checkBox_kill.checkState()) # force update
self.ui.checkBox_hover.toggled.connect(self.flie.setHoverDisabled)
self.ui.checkBox_hover.toggled.emit(
self.ui.checkBox_hover.checkState()) # force update
self.ui.checkBox_reconnect.toggled.connect(self.setAutoReconnect)
self.ui.checkBox_startupConnect.toggled.connect(self.setStartupConnect)
self.ui.pushButton_genRosMsg.clicked.connect(self.genRosMsg)
self.ui.pushButton_baro.clicked.connect(self.updateBaroTopics)
self.ui.groupBox_baro.toggled.connect(
lambda x: self.updateBaroTopics(not x))
# Connections to GUI
self.flie.sig_packetSpeed.connect(self.updatePacketRate)
self.flie.sig_flieLink.connect(self.ui.progressbar_link.setValue)
self.paramManager.sig_baroFound.connect(
lambda found: self.ui.label_baroFound.setText("Yes"
if found else "No"))
self.paramManager.sig_magFound.connect(
lambda found: self.ui.label_magFound.setText("Yes"
if found else "No"))
self.paramManager.sig_test.connect(lambda name, p: self.ui.labelTest[
str(name)].setText("Pass" if p else "FAIL"))
self.paramManager.sig_firmware.connect(
lambda fw, mod: self.ui.label_fw.setText(fw))
self.paramManager.sig_firmware.connect(
lambda fw, mod: self.ui.label_fwMod.setText(mod))
self.logManager.sig_batteryUpdated.connect(lambda v: self.setToUpdate(
"vbat", self.ui.progressbar_bat.setValue, v))
self.logManager.sig_cpuUpdated.connect(lambda v: self.setToUpdate(
"cpu", self.ui.progressbar_cpu.setValue, v))
self.flie.inKBPS.sig_KBPS.connect(
lambda hz: self.updatePacketRate(self.ui.progressBar_pktIn, hz))
self.flie.outKBPS.sig_KBPS.connect(
lambda hz: self.updatePacketRate(self.ui.progressBar_pktOut, hz))
# Connections GUI to GUI
# Connections Within
self.scanner.sig_foundURI.connect(self.receiveScanURI)
self.sig_requestScan.connect(self.scanner.scan)
self.sig_requestConnect.connect(self.flie.requestConnect)
self.sig_requestDisconnect.connect(self.flie.requestDisconnect)
self.flie.sig_stateUpdate.connect(self.updateFlieState)
self.flie.sig_console.connect(self.ui.console.insertPlainText)
# Show window
self.show()
# Initiate an initial Scan
init_drivers(enable_debug_driver=False)
self.startScanURI()
present_mode = not present_mode
if present_mode:
write("Present mode")
else:
write("Attendance mode")
# Calls the sync_data method and alerts user on success or failure
def sync(data):
global present_mode
write("Syncing...")
if s.sync_data(data + ',' + ('P' if present_mode else 'A')):
write("Successfully synced data")
else:
write("Error syncing, please try again")
# Calls the scan method and returns the found data
def scan_code():
write("Please display code")
return scan()
write("System starting up...")
present_mode = False
s = Sync()
cad = pifacecad.PiFaceCAD()
listener = pifacecad.SwitchEventListener(chip=cad)
listener.register(4, pifacecad.IODIR_FALLING_EDGE, scan_and_sync)
listener.register(0, pifacecad.IODIR_FALLING_EDGE, switch_modes)
listener.activate()
write("Startup complete...")
ALARM_FORMAT = re.compile(r'([<>])(\d+(?:\.\d+)*) (btc|usd)')
closing = threading.Event()
def send(to, msg):
requests.get('https://api.telegram.org/%s/sendMessage'%BOT_ID,
params = {'chat_id':to, 'text':unicode.encode(msg, 'utf-8')}
)
#retrieve previous data
try:
print "recovering environment:",
env_file = open('env', 'rb')
environ = pickle.load(env_file)
offset = environ['offset']
alarms = Sync(environ['alarms'])
chats = Sync(environ['chats'])
last_price_btc = environ['last_price_btc']
last_price_usd = environ['last_price_usd']
env_file.close()
print "success"
except Exception as e:
env_file = open('env', 'wb')
alarms = Sync({})
chats = Sync({})
offset = 0
last_price_btc = 0
last_price_usd = 0
environ = {'offset':offset, 'alarms':alarms.container, 'chats':chats.container, 'last_price_btc': last_price_btc, 'last_price_usd':last_price_usd}
pickle.dump(environ, env_file)
env_file.close()
if purge_time:
self.purge_counter += 1
if self.purge_counter == purge_sleep_ratio:
try:
purge = Purge(self.__prefs, purge_time)
except Exception, e:
logging.getLogger().exception(e)
raise
self.purge_counter = 0
if sync_sleep_ratio:
#debug("sync count: %d", self.sync_counter)
self.sync_counter += 1
if self.sync_counter == sync_sleep_ratio:
try:
sync = Sync(self.__prefs)
if self.__sync_upload:
debug("sync upload")
timestamp = sync.send_new_hosts()
if self.__sync_download:
debug("sync download")
new_hosts = sync.receive_new_hosts()
if new_hosts:
info("received new hosts: %s", str(new_hosts))
self.get_denied_hosts()
self.update_hosts_deny(new_hosts)
sync.xmlrpc_disconnect()
except Exception, e:
logging.getLogger().exception(e)
raise
self.sync_counter = 0
def main():
parser = argparse.ArgumentParser(
description='Upload, download or sync photos and videos to Flickr.')
parser.add_argument(
'--custom-set',
type=str,
help=
'customize set title from path using standard regex, e.g. "(.*)/(.*)"')
parser.add_argument(
'--custom-set-builder',
type=str,
help=
'build a custom set title using matched groups, e.g. "{0}{1}" joins first two "(.*)/(.*)"'
)
parser.add_argument(
'--download',
type=str,
help='download photos; specify a path or use "." for all')
parser.add_argument(
'--dry-run',
action='store_true',
help='report actions but do not change local/remote sets')
parser.add_argument('--fix-missing-description',
action='store_true',
help='replace missing set description with set title')
parser.add_argument(
'--ignore-extensions',
type=str,
help='comma separated list of filename extensions to ignore')
parser.add_argument(
'--ignore-images',
action='store_true',
help='ignore image files: jpg, jpeg, png, gif, tif, tiff, bmp')
parser.add_argument(
'--ignore-videos',
action='store_true',
help=
'ignore video files: m4v, mp4, avi, wmv, mov, mpg, mpeg, 3gp, mts, m2ts, ogg, ogv'
)
parser.add_argument(
'--keywords',
action='append',
type=str,
help='only upload files with IPTC metadata matching these keywords')
parser.add_argument(
'--nobrowser',
action='store_true',
help='support manual authentication when no web browser is available')
parser.add_argument('--starts-with',
type=str,
help='only upload paths starting with this text')
parser.add_argument(
'--sync',
action='store_true',
help=
'upload anything not on Flickr; download anything not on local filesystem'
)
parser.add_argument(
'--sync-path',
type=str,
default=os.getcwd(),
help=
'sync path (default: current dir); individual files in --sync-path root are not synced to avoid disorganized Flickr sets'
)
parser.add_argument('--version',
action='store_true',
help='print current version: ' + version)
args = parser.parse_args()
args.windows = os.name == "nt"
if args.version:
logger.info('--version %s', version)
exit(0)
else:
logger.debug('--version %s', version)
args.sync_path = args.sync_path.rstrip(
os.sep) + os.sep # ensure sync path ends with "/"
if not os.path.exists(args.sync_path):
logger.error('--sync-path "%s" does not exist', args.sync_path)
exit(0)
local = Local(args)
remote = Remote(args)
sync = Sync(args, local, remote)
sync.start_sync()
import gevent
import sys
from sync import Sync
from settings import generateDefaultSetting
from BoardCode import HAKSA
if __name__ == "__main__":
setting = generateDefaultSetting()
sync = Sync(setting, HAKSA)
if len(sys.argv) > 1:
if sys.argv[1] == "firstRun":
sync.firstRun()
print(len(sync.keys()))
elif sys.argv[1] == "Run":
keys = len(sync.keys())
[sync.delete(i) for i in range(keys - 3, keys + 1)]
print(len(sync.keys()))
sync.Run()
print(len(sync.keys()))
[sync.delete(i) for i in range(keys - 30, keys + 1)]
print(len(sync.keys()))
sync.Run()
print(len(sync.keys()))
def main():
parser = argparse.ArgumentParser(
description='Sync current folder to your flickr account.')
parser.add_argument('--monitor',
action='store_true',
help='starts a daemon after sync for monitoring')
parser.add_argument(
'--starts-with',
type=str,
help='only sync that path starts with this text, e.g. "2015/06"')
parser.add_argument(
'--download',
type=str,
help='download the photos from flickr, specify a path or . for all')
parser.add_argument('--ignore-videos',
action='store_true',
help='ignore video files')
parser.add_argument('--ignore-images',
action='store_true',
help='ignore image files')
parser.add_argument(
'--ignore-ext',
type=str,
help='comma separated list of extensions to ignore, e.g. "jpg,png"')
parser.add_argument('--version',
action='store_true',
help='output current version: ' + version)
parser.add_argument(
'--sync-path',
type=str,
default=os.getcwd(),
help='specify the sync folder (default is current dir)')
parser.add_argument(
'--sync-from',
type=str,
help=
'Only supported value: "all". Uploads anything that isn\'t on flickr, and download anything that isn\'t on the local filesystem'
)
parser.add_argument(
'--custom-set',
type=str,
help='customize your set name from path with regex, e.g. "(.*)/(.*)"')
parser.add_argument(
'--custom-set-builder',
type=str,
help=
'build your custom set title, e.g. "{0} {1}" to join the first two groups (default merges groups with hyphen)'
)
parser.add_argument(
'--update-custom-set',
action='store_true',
help=
'updates your set title from custom-set (and custom-set-builder, if given)'
)
parser.add_argument(
'--custom-set-debug',
action='store_true',
help=
'for testing your custom sets, asks for confirmation when creating an album on flickr'
)
parser.add_argument(
'--username', type=str,
help='token username') # token username argument for api
parser.add_argument('--keyword',
action='append',
type=str,
help='only upload files matching this keyword')
args = parser.parse_args()
if args.version:
logger.info(version)
exit()
# validate args
args.is_windows = os.name == 'nt'
args.sync_path = args.sync_path.rstrip(os.sep) + os.sep
if not os.path.exists(args.sync_path):
logger.error('Sync path does not exists')
exit(0)
local = Local(args)
remote = Remote(args)
sync = Sync(args, local, remote)
sync.start_sync()
def init_sync(self):
self._sync = Sync(self._root_dir_path, self._working_dir_path, self._content, self._db, self._ipfs_client,
self._cipher)
