def init_client(c=None):
global client
if c is None:
c = putio.Client(app.config['PUTIO_TOKEN'], use_retry=True)
client = c
return c
def download_file(id, delete_after_download=True, download_dir="./"):
putio_client = putiopy.Client(config_map['oauth'])
file = putio_client.File.get(int(id))
print('Downloading file: {}'.format(str(file)))
file.download(dest=download_dir, delete_after_download=delete_after_download)
print('Download complete!')
return file.name
def __init__(self, **kwargs):
"""Put.io Aria2c downloader.
Attributes:
keep_folder_structure (bool): keep the same structure as on put.io
aria2c_secret_token (str): aria2c rpc secret token
incomplete_dir (int): put.io folder to start recursing from
complete_dir (str): Where to move completed downloads
watch_list (dict): folders to watch in incomplete_dir on put.io
putio_client: putio.py library client object
aria_client: aria2c xmlrpc client object
"""
self.logger = logging.getLogger('putio.' + __name__)
self.keep_folder_structure = kwargs.get('keep_folder_structure', True)
aria2c_secret_token = kwargs.get("aria2c_secret_token")
self.aria2c_secret_token = f'token:{aria2c_secret_token}'
self.incomplete_dir = kwargs.get('incomplete_dir', tempfile.mkdtemp())
self.complete_dir = kwargs.get('complete_dir', os.getcwd())
self.watch_list = kwargs.get('watch_folders', [])
self.putio_client = putiopy.Client(kwargs.get('oauth_token'),
use_retry=True,
timeout=10)
self.aria_client = xmlrpc.client.ServerProxy(kwargs.get('rpc_url'))
def __init__(self, **kwargs):
"""Putio Aria2c Downloader
Attributes:
keep_folder_structure (bool): Whether or not to keep the same folder structure as
on put.io
aria2c_secret_token (str): aria2c rpc secret token
root_download_dir (int): Which folder id (on put.io) to start recursing from
post_process_dir (str): Where to move completed downloads
watch_list (dict): folder names to watch inside root_download_dir on put.io
putio_client: putiopy library client object
aria_client: aria2c xmlrpc client object
"""
self.logger = logging.getLogger('putio.' + __name__)
self.keep_folder_structure = kwargs.get('keep_folder_structure', True)
self.aria2c_secret_token = 'token:%s' % kwargs.get(
'aria2c_secret_token', None)
self.root_download_dir = kwargs.get('root_download_dir',
tempfile.mkdtemp())
self.post_process_dir = kwargs.get('post_process_dir', os.getcwd())
self.watch_list = kwargs.get('watch_folders', [])
self.putio_client = putiopy.Client(kwargs.get('oauth_token', None))
self.aria_client = xmlrpc.client.ServerProxy(
kwargs.get('rpc_url', None))
def setUp(self):
self.fd, app.config['DATABASE'] = tempfile.mkstemp()
app.config['TESTING'] = True
app.config['TORRENTS'] = tempfile.mkdtemp()
self.app = app.test_client()
init_db()
self.client = init_client(putio.Client('123456'))
def __init__(self):
manager = Manager()
self.pcloud = PyCloud(PCLOUD_USER, PCLOUD_PASS)
self.putio = putiopy.Client(PUTIO_KEY)
self.download_list = manager.list()
self.upload_list = manager.list()
self.files_left = manager.Value(1, 0)
self.destination = None
def main(config):
client = putiopy.Client(config['oauth_token'])
root_files = client.File.list()
for file in root_files:
if file.name in config['public_directories']:
purge_old_files(client, file, config['delete_after_days'])
if file.name not in config['allowed_root_files']:
print(f'Deleting unauthorized root file {file.name}')
file.delete()
def auto_delete(oauth_token: str,
max_age: "num",
dryrun: bool,
excluded_dirs: list = []):
"""Deletes files older than `max_age` days from the putio account associated with
the `oauth_token`. The folders (NOT their contents) in `excluded_dirs` will be
left even if they match the age criteria.
Returns True if files have been found/deleted matching the age criteria.
False if no files were found.
"""
client = putiopy.Client(oauth_token)
max_age_delta = datetime.timedelta(days=max_age)
cutoff_date = datetime.datetime.today() - max_age_delta
files = client.File.list(
parent_id=-1, file_type="FILE,AUDIO,VIDEO,IMAGE,ARCHIVE,PDF,TEXT,SWF")
old_files = [file_ for file_ in files if file_.created_at < cutoff_date]
for file_ in old_files:
if dryrun:
print(" Old file Found: {}".format(file_.name))
else:
try:
file_.delete(True)
except:
print("[x] Could not delete: {}".format(file_.name))
else:
print(" File Deleted: {}".format(file_.name))
time.sleep(0.2)
folders = client.File.list(parent_id=-1, file_type="FOLDER")
old_folders = [
folder for folder in folders if folder.created_at < cutoff_date
and folder.size == 0 and folder.name not in excluded_dirs
]
for folder in old_folders:
if dryrun:
print(" Old folder Found: {}".format(folder.name))
else:
try:
folder.delete(True)
except:
print("[x] Could not delete: {}".format(folder.name))
else:
print(" Folder Deleted: {}".format(folder.name))
time.sleep(0.2)
if old_files or old_folders:
return True
else:
return False
def get_client():
global client
if not os.path.isfile("holeio.cfg"):
return None
if client:
return client
config = ConfigParser.RawConfigParser()
config.read("holeio.cfg")
token = config.get('oauth', 'token')
if token:
client = putiopy.Client(token)
return client
logger.error('No oauth token set')
def __init__(self, options):
# update options from config file
config = ConfigParser.RawConfigParser()
config.read(os.path.expanduser(options['--config']))
for section in config.sections():
for key, value in config.items(section):
key = section + '.' + key
options[key] = value
Base.__init__(self, options)
# define putio client
self.client = putiopy.Client(options['Settings.oauth-token'])
def MovieFinder(moviename):
response = ''
link = MovieSearch(moviename)
if link == 'No results found':
response = 'No results found for' + moviename
elif "1080p" in link:
try:
client = putiopy.Client(pkey.OAUTH_KEY)
client.Transfer.add_url(link)
response = "You'll be able to watch " + moviename + " on Put IO soon..."
except Exception:
return 'Something went wrong adding file to Put IO.'
else:
# instantiate a Client using the appropriate WebUI configuration
qbt_client = qbit.Client(host=qbt_auth['host'],
username=qbt_auth['username'],
password=qbt_auth['password'])
# the Client will automatically acquire/maintain a logged in state in line with any request.
# therefore, this is not necessary; however, you many want to test the provided login credentials.
try:
qbt_client.auth_log_in()
except qbit.LoginFailed:
return 'Could not authenticate. Qbt is probably down.'
# add download link to qbt client
# help(qbt_client.torrents_add)
try:
qbt_client.torrents_add(urls=link,
save_path=path_to_save,
is_paused=False)
response = "You'll be able to watch " + moviename + " in 4K soon..."
except Exception:
return 'Something went wrong adding file to Qbt.'
try:
with open("/var/www/piAppSwitcher/MovieFinder/MFResponses.txt",
mode='a+') as txtfile:
txtfile.write('On ' +
datetime.now().strftime("%Y-%m-%d %H:%M:%S") +
' MovieFinder sent response "' + response + '".\n')
except IOError:
print("Couldn't write to file!")
# Send response to Telegram Chat
payload = dict(chat_id=tkeys.chat_id, text=response)
requests.post(tkeys.url, data=payload)
return response
def ConfigurePutIOClient(id_IN, secret_IN, token_IN, callback_IN,
authenticate_IN):
# Just annoying numbers and values to keep track of...
CLIENT_ID = id_IN
CLIENT_SECRET = secret_IN
OAUTH_TOKEN = token_IN
CALLBACK_URL = callback_IN
# Some authentication code I copy pasted from their github.
# Only works if specified by function call.
if (authenticate_IN):
helper = putiopy.AuthHelper(CLIENT_ID,
CLIENT_SECRET,
CALLBACK_URL,
type='token')
helper.open_authentication_url()
# Set client here.
client = putiopy.Client(OAUTH_TOKEN)
return client
def add_entries(self, task, config):
""" Main function. """
client = putiopy.Client(config.get("token"))
for entry in task.accepted:
form_data = {}
if entry.get('dir'):
form_data['dir'] = entry.render(entry['dir'])
dir_id = self.get_directory_id(client, form_data, config)
if dir_id == 0:
self.create_folder(client, form_data, config)
dir_id = self.get_directory_id(client, form_data, config)
log.info("Destination directory is %s", form_data.get("dir"))
else:
dir_id = config.get("root_dir_id")
log.info("Destination directory ID is %s", dir_id)
""" Adds a new transfer. """
self.add_torrent_url(client, entry['url'], dir_id)
""" Clean completed transfer. """
if config.get('clean_completed'):
self.clean_completed(client)
def __init__(self):
global config
self.putio = putiopy.Client(config["token"])
self.config = config
import putiopy
from ring_doorbell import Ring
import config
#Have the ring videos downloaded to put.io
helper = putiopy.AuthHelper(config.client, config.application_secret,
"https://webhook.site/6e8bc62f-477b-44e6-a67f-9c39795eefb9", type='token')
client = putiopy.Client(config.token)
helper.open_authentication_url()
#apples = client.File.search("6740617731310688069", 1)
#print(apples)
List_files_on_putio = client.File.list()
print(List_files_on_putio)
#print(List_files_on_putio[2:5])
mylist = List_files_on_putio.copy()
testlist = ["6742976248176777029", "6742974031973652293", "6742972232382355269", "6742971635381901125", "6742971343324124997"]
#TODO: get rid of the char del, its no longer needed since getting mylist[x].id no longer cuts off part of the id.
#remove the last two characters in the string for each.
newtestlist = [x[:-2] for x in testlist]
#print("New test list is now " + str(newtestlist))
def ringtoputio():
ringdict = defaultdict(list)
videocount = total_video_count(
) # video count holds the total amount of videos
numberofvideos = int(
input("How many videos do you want to be sent to put.io?\n\n" +
"The larger the number of videos "
"requestd, the longer it will take "
"to complete :"))
downloasdurl = [] # this will hold all of the download urls.
eventidlist = [] # the list that will hold the video ID's
myring = Ring(
config.username,
config.password) # enters the password and username for ring.
doorbell = myring.doorbells[
0] # gets the first doorbell found in the ring list.
# if the number of videos asked for is less than 100
if numberofvideos < 100:
print("number of videos requested is less than 100.\n\n")
for doorbell in myring.doorbells:
# list the number of events requested by user
for event in doorbell.history(limit=numberofvideos):
eventidlist.append(
event['id']) # appends the eventids to the eventidlist.
ringdict["Date"].append(event['created_at'])
ringdict["ID"].append(event['id'])
print(ringdict)
print("ringIDs in the dict is " + str(ringdict["ID"]))
print("the length of eventid list is " + str(
len(eventidlist))) # prints the length of list id eventidlist
print("eventidlist is " + str(eventidlist)
) # prints out all of the items in the eventID list.
else:
for doorbell in myring.doorbells:
# listing the last 100 events of any kind
for event in doorbell.history(limit=100):
eventidlist.append(
event['id']) # appends the eventids to the eventidlist.
print("the length of eventid list is " + str(len(eventidlist)))
print("eventidlist is ...\n\n" + str(eventidlist))
histroy = doorbell.history(limit=100, older_than=eventidlist[-1])
while (len(eventidlist) < numberofvideos):
histroy = doorbell.history(limit=100, older_than=eventidlist[-1])
for event in histroy:
# print('ID: %s' % event['id'])
eventidlist.append(event['id']) # adds the IDs to the list.
eventidlist = list(dict.fromkeys(
eventidlist)) # removes any duplicates in the list.
print("the length of eventid list is " + str(len(eventidlist)))
print("event id list is " + str(eventidlist))
print(
"Time to start getting the video links for the ring videos\n\n This will take a while"
)
for x in eventidlist:
adddownloadurl = doorbell.recording_url(x)
downloasdurl.append(adddownloadurl)
print(downloasdurl)
print("Number of Video links obtained " + str(len(downloasdurl)) +
" / " + str(numberofvideos))
#Have the ring videos downloaded to put.io
helper = putiopy.AuthHelper(
config.client,
config.application_secret,
"https://webhook.site/6e8bc62f-477b-44e6-a67f-9c39795eefb9",
type='token')
client = putiopy.Client(config.token)
helper.open_authentication_url()
lengthofdownloadlist = len(downloasdurl)
for i in range(lengthofdownloadlist):
transfer = client.Transfer.add_url(str(downloasdurl[i]))
print("progress on sending links to put.io" + str(i + 1) + "/" +
str(len(downloasdurl))
) # shows the number of links sent to put.io so far.
List_files_on_putio = client.File.list()
print(List_files_on_putio)
# print(List_files_on_putio[2:5])
mylist = List_files_on_putio.copy()
#print("The min and high list value of the mylist" + min(mylist), max(mylist))
#TODO: Should try using this one instead. Add a delay that will make sure all of the transfers are done then check the files.
#for x in range(0, int(len(ringdict))):
#any(ringdict["ID"] in ringdict for ringdict["ID"] in mylist)
#print("I FOUND SOMETHING" + str(mylist[x].name))
for index, item in enumerate(mylist):
for id in ringdict["ID"]:
if str(id) in item["name"]:
print(f"I found {id} at index {index}")
def upload_torrent_to_putio(token, filename, parent_id):
client = putiopy.Client(token)
client.Transfer.add_torrent(filename, parent_id)
os.remove(filename)
def get(token: str, file_id: int):
def log(*args):
print(f'[{token[:4]}]', *args)
client = putiopy.Client(token)
files: Dict[int, File] = {}
processed = 0
try:
root = client.File.get(file_id)
except putiopy.ClientError as e:
if e.response.status_code == 401 and file_id == 0:
raise ExpiredToken
raise
total_size = root.size
log("total size of file(%d): %d gb" % (file_id, total_size // 2**30))
def append_children_recursive(putio_file, total_sizes: Queue,
level: int) -> None:
nonlocal processed
children = list_children(putio_file.id, client)
threads = []
children_sizes: Queue[int] = Queue()
for child in children:
if child.folder_type == 'SHARED_ROOT':
continue
if (level < MAX_LEVEL
and child.content_type == 'application/x-directory'):
t = threading.Thread(target=append_children_recursive,
args=(child, children_sizes, level + 1))
t.start()
threads.append(t)
else:
children_sizes.put(child.size)
files[child.id] = File(child, child.size)
processed += child.size
log("processed %d of %d gb" %
(processed // 2**30, total_size // 2**30))
for t in threads:
t.join()
children_size = 0
while True:
try:
children_size += children_sizes.get_nowait()
except Empty:
break
dir_size = putio_file.size
if children_size > dir_size:
dir_size = children_size
total_sizes.put(dir_size)
files[putio_file.id] = File(putio_file, dir_size)
start = time.time()
append_children_recursive(root, Queue(), level=1)
end = time.time()
log('file tree traversed in %s seconds' % (end - start))
ids = []
labels = []
values = []
parents = []
for id, file in files.items():
ids.append(file.id)
labels.append(file.name)
values.append(file.size)
try:
parents.append(files[file.parent_id].id)
except KeyError:
parents.append('')
fig = go.Figure(
go.Treemap(
ids=ids,
labels=labels,
values=values,
parents=parents,
branchvalues='total',
texttemplate='%{label}',
hovertemplate='%{label}<br>%{value:.2s}<extra></extra>',
))
return fig.to_html(include_plotlyjs='cdn')
def start_sync(args):
formatter = logging.Formatter(
'%(asctime)s | %(name)-12s | %(levelname)-8s | %(message)s')
log_level = logging.ERROR
if args.log_level is not None:
if args.log_level == "debug":
log_level = logging.DEBUG
elif args.log_level == "info":
log_level = logging.INFO
elif args.log_level == "warning":
log_level = logging.WARNING
elif args.log_level == "error":
log_level = logging.ERROR
elif args.log_level == "critical":
log_level = logging.CRITICAL
else:
print("Invalid log-level argument")
ch = logging.StreamHandler()
ch.setLevel(log_level)
ch.setFormatter(formatter)
if args.log is not None:
fh = logging.FileHandler(args.log)
fh.setLevel(log_level)
fh.setFormatter(formatter)
logger.addHandler(fh)
else:
logger.addHandler(ch)
log_webif = logging.getLogger('werkzeug')
log_webif.setLevel(log_level)
log_webif.disabled = True
if args.log_webif is not None:
fh = logging.FileHandler(args.log_webif)
fh.setLevel(log_level)
fh.setFormatter(formatter)
log_webif.addHandler(fh)
else:
log_webif.addHandler(ch)
# Restore or obtain a valid token
token_manager = TokenManager()
token = token_manager.get_token()
while not token_manager.is_valid_token(token):
print("No valid token found! Please provide one.")
token = token_manager.obtain_token()
token_manager.save_token(token)
# Let's start syncing!
putio_client = putiopy.Client(token)
db_manager = DatabaseManager()
download_manager = DownloadManager(token=token)
if args.post_process_command is not None:
download_manager.add_download_completion_callback(
build_postprocess_download_completion_callback(
args.post_process_command))
if args.watch_directory is not None:
torrent_watcher = TorrentWatcher(args.watch_directory, putio_client)
torrent_watcher.start()
filter_compiled = None
if args.filter is not None:
try:
filter_compiled = re.compile(args.filter)
except re.error as e:
print("Invalid filter regex: {0}".format(e))
exit(1)
force_keep_compiled = None
if args.force_keep is not None:
try:
force_keep_compiled = re.compile(args.force_keep)
except re.error as e:
print("Invalid force_keep regex: {0}".format(e))
exit(1)
download_manager.start()
synchronizer = PutioSynchronizer(
download_directory=args.download_directory,
putio_client=putio_client,
db_manager=db_manager,
download_manager=download_manager,
keep_files=args.keep,
poll_frequency=args.poll_frequency,
download_filter=filter_compiled,
force_keep=force_keep_compiled,
disable_progress=args.log is not None)
t = threading.Thread(target=synchronizer.run_forever)
t.setDaemon(True)
t.start()
web_interface = WebInterface(db_manager,
download_manager,
putio_client,
synchronizer,
launch_browser=(not args.quiet),
host=args.host,
port=args.port)
web_interface.run()
def create_client(putio_token):
return putiopy.Client(putio_token)
def __init__(self, token):
self._client = putiopy.Client(token)
import json
import logging
import os
import putiopy
import requests
from dumbdb import DumbDB
logging.basicConfig(
level=getattr(logging,
os.environ.get('LOG_LEVEL', 'warning').upper()))
log = logging.getLogger()
client = putiopy.Client(os.environ['PUTIO_OAUTH_TOKEN'])
downloaded_files = DumbDB('downloaded_before.txt')
def get_missing_files(file_resources):
missing_files = []
for file_resource in file_resources:
log.debug(' ↦ Analysing %s %d %s', file_resource.file_type,
file_resource.id, file_resource.name)
log.debug(' ↦ Maybe wanted %d %s', file_resource.id,
file_resource.name)
if downloaded_files.exists(file_resource.id):
continue
missing_files.append(file_resource)
CallbackQueryHandler,
# ConversationHandler,
# MessageHandler,
# Filters,
# RegexHandler,
)
# LOGGER for warnings, errors, debug outputs etc.
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
# fundamentals
logger = logging.getLogger(__name__)
bot_token = os.environ['BOT_TOKEN']
client = putiopy.Client(os.environ['PUT_IO_TOKEN'])
# put.io folder to collect user files (/BOT_USERS/)
USERS_DIR_ID = 111111111
# catch errors
def error(bot, update, error):
"""Log Errors caused by Updates."""
logger.warning('Update "%s" caused error "%s"', update, error)
# /start function
def start(bot, update, user_data):
# create user instance in the db if doesn't exist
markup = InlineKeyboardMarkup(MAIN_MENU)
def setUp(self):
self.client = putiopy.Client('123456')
self.destination = tempfile.mkdtemp()
def create_client(app):
"Create a Put.IO client"
if 'PUTIO_TOKEN' in app.config:
client = putio.Client(app.config['PUTIO_TOKEN'], use_retry=True)
return client
