You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
430 lines
12 KiB
Python
430 lines
12 KiB
Python
## CONFIG
|
|
# change this to your external ip address for your server
|
|
#(needs to be external to allow tor routing)
|
|
from config import *
|
|
import os,sys; sys.path.append(os.path.abspath(os.path.join(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')),'..')))
|
|
from komrade import *
|
|
|
|
import logging
|
|
logger=logging.getLogger(__name__)
|
|
|
|
# monkeypatching the things that asyncio needs
|
|
import subprocess
|
|
subprocess.PIPE = -1 # noqa
|
|
subprocess.STDOUT = -2 # noqa
|
|
subprocess.DEVNULL = -3 # noqa
|
|
|
|
|
|
import asyncio
|
|
import os
|
|
os.environ['KIVY_EVENTLOOP'] = 'asyncio'
|
|
# loop = asyncio.get_event_loop()
|
|
# loop.set_debug(True)
|
|
|
|
# imports
|
|
from kivy.uix.screenmanager import Screen,ScreenManager
|
|
from kivymd.app import MDApp
|
|
from kivymd.uix.button import MDFillRoundFlatButton, MDIconButton
|
|
from kivymd.uix.toolbar import MDToolbar
|
|
from kivymd.uix.screen import MDScreen
|
|
from kivymd.uix.dialog import MDDialog
|
|
from kivy.lang import Builder
|
|
from kivy.uix.boxlayout import BoxLayout
|
|
from kivymd.theming import ThemeManager
|
|
from kivy.properties import ObjectProperty,ListProperty
|
|
import time,os
|
|
from collections import OrderedDict
|
|
from functools import partial
|
|
from kivy.uix.screenmanager import NoTransition
|
|
from kivymd.uix.label import MDLabel
|
|
from kivy.uix.widget import Widget
|
|
from kivymd.uix.list import OneLineListItem
|
|
from kivymd.uix.card import MDCard, MDSeparator
|
|
from kivymd.uix.boxlayout import MDBoxLayout
|
|
from kivy.uix.gridlayout import GridLayout
|
|
from kivy.metrics import dp
|
|
from kivy.properties import NumericProperty
|
|
from kivymd.uix.list import * #MDList, ILeftBody, IRightBody, ThreeLineAvatarListItem, TwoLineAvatarListItem, BaseListItem, ImageLeftWidget
|
|
from kivy.uix.image import Image, AsyncImage
|
|
import requests,json
|
|
from kivy.storage.jsonstore import JsonStore
|
|
from kivy.core.window import Window
|
|
from kivy.core.text import LabelBase
|
|
import shutil,sys
|
|
from kivy.uix.image import Image
|
|
import sys
|
|
sys.path.append("..") # Adds higher directory to python modules path.
|
|
|
|
from kivy.event import EventDispatcher
|
|
import threading,asyncio,sys
|
|
|
|
# raise Exception(str(Window.size))
|
|
Window.size = WINDOW_SIZE
|
|
# Window.fullscreen = True #'auto'
|
|
|
|
# with open('log.txt','w') as of:
|
|
# of.write('### LOG ###\n')
|
|
def rgb(r,g,b,a=1):
|
|
return (r/255,g/255,b/255,a)
|
|
|
|
class MyLayout(MDBoxLayout):
|
|
scr_mngr = ObjectProperty(None)
|
|
post_id = ObjectProperty()
|
|
|
|
@property
|
|
def app(self):
|
|
if not hasattr(self,'_app'):
|
|
from kivy.app import App
|
|
self._app = App.get_running_app()
|
|
return self._app
|
|
|
|
def rgb(self,r,g,b,a=1):
|
|
return rgb(r,g,b,a=a)
|
|
|
|
def change_screen(self, screen, *args):
|
|
self.scr_mngr.current = screen
|
|
|
|
def change_screen_from_uri(self,uri,*args):
|
|
self.app.uri=uri
|
|
screen_name = route(uri)
|
|
self.app.screen = screen_name
|
|
self.app.log(f'routing to {screen_name}')
|
|
self.scr_mngr.current = screen_name
|
|
|
|
def view_post(self,post_id):
|
|
self.post_id=post_id
|
|
self.change_screen('view')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ProgressPopup(MDDialog): pass
|
|
class MessagePopup(MDDialog): pass
|
|
class MessagePopupCard(MDDialog): pass
|
|
class MyBoxLayout(MDBoxLayout): pass
|
|
class MyLabel(MDLabel): pass
|
|
|
|
class MyToolbar(MDToolbar):
|
|
action_icon_color = ListProperty()
|
|
|
|
def update_action_bar(self, action_bar, action_bar_items):
|
|
action_bar.clear_widgets()
|
|
new_width = 0
|
|
for item in action_bar_items:
|
|
new_width += dp(48)
|
|
action_bar.add_widget(
|
|
MDIconButton(
|
|
icon=item[0],
|
|
on_release=item[1],
|
|
opposite_colors=True,
|
|
text_color=(self.specific_text_color if not self.action_icon_color else self.action_icon_color),
|
|
theme_text_color="Custom",
|
|
)
|
|
)
|
|
action_bar.width = new_width
|
|
|
|
def update_action_bar_text_colors(self, instance, value):
|
|
for child in self.ids["left_actions"].children:
|
|
if not self.action_icon_color:
|
|
child.text_color = self.specific_text_color
|
|
else:
|
|
child.text_color = self.action_icon_color
|
|
|
|
for child in self.ids["right_actions"].children:
|
|
if not self.action_icon_color:
|
|
child.text_color = self.specific_text_color
|
|
else:
|
|
child.text_color = self.action_icon_color
|
|
|
|
|
|
|
|
|
|
def draw_background(widget, img_fn='assets/bg.png'):
|
|
from kivy.core.image import Image as CoreImage
|
|
from kivy.graphics import Color, Rectangle
|
|
widget.canvas.before.clear()
|
|
with widget.canvas.before:
|
|
Color(.4, .4, .4, 1)
|
|
texture = CoreImage(img_fn).texture
|
|
texture.wrap = 'repeat'
|
|
nx = float(widget.width) / texture.width
|
|
ny = float(widget.height) / texture.height
|
|
Rectangle(pos=widget.pos, size=widget.size, texture=texture,
|
|
tex_coords=(0, 0, nx, 0, nx, ny, 0, ny))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#### LOOPER
|
|
|
|
|
|
|
|
def route(uri):
|
|
if not '/' in uri: return None
|
|
prefix=uri.split('/')[1] #,channel,rest = uri.split('/',3)
|
|
|
|
mapd = {
|
|
'inbox':'feed',
|
|
'outbox':'feed',
|
|
'login':'login',
|
|
}
|
|
return mapd.get(prefix,None)
|
|
|
|
|
|
|
|
# DEFAULT_SCREEN = route(DEFAULT_URI)
|
|
|
|
class MainApp(MDApp, Logger):
|
|
title = 'Komrade'
|
|
logged_in=False
|
|
login_expiry = 60 * 60 * 24 * 7 # once a week
|
|
texture = ObjectProperty()
|
|
uri='/do/login'
|
|
|
|
def rgb(self,*_): return rgb(*_)
|
|
|
|
def change_screen(self, screen, *args):
|
|
self.screen=screen
|
|
self.root.change_screen(screen,*args)
|
|
|
|
def get_username(self): return self._name
|
|
|
|
@property
|
|
def crypt(self):
|
|
if not hasattr(self,'_crypt'):
|
|
from komrade.backend.crypt import Crypt
|
|
self._crypt = Crypt(
|
|
fn=PATH_CRYPT_CA_DATA,
|
|
encrypt_values=False,
|
|
)
|
|
return self._crypt
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
self.event_loop_worker = None
|
|
self.loop=asyncio.get_event_loop()
|
|
|
|
# connect to API
|
|
self.komrade=None
|
|
self._name=''
|
|
|
|
|
|
def build(self):
|
|
# bind
|
|
global app,root
|
|
app = self
|
|
|
|
# load root
|
|
self.root = root = Builder.load_file('root.kv')
|
|
draw_background(self.root)
|
|
|
|
# edit logo
|
|
toolbar=root.ids.toolbar
|
|
toolbar.md_bg_color = root.rgb(*COLOR_TOOLBAR)
|
|
toolbar.action_icon_color=root.rgb(*COLOR_ICON)
|
|
logo=toolbar.ids.label_title
|
|
logo.font_name='assets/Strengthen.ttf'
|
|
logo.font_size='58dp'
|
|
logo.pos_hint={'center_y':0.43}
|
|
logo.text_color=root.rgb(*COLOR_LOGO)
|
|
|
|
self.root.change_screen_from_uri(self.uri if self.uri else DEFAULT_URI)
|
|
|
|
|
|
|
|
|
|
return self.root
|
|
|
|
# def boot(self,username):
|
|
# kommie = Komrade(username)
|
|
# if self.exists_locally_as_contact()
|
|
|
|
|
|
def load_store(self):
|
|
if not self.store.exists('user'): return
|
|
userd=self.store.get('user')
|
|
if not userd: return
|
|
|
|
self.username = userd.get('username','')
|
|
|
|
|
|
|
|
async def upload(self,filename,file_id=None):
|
|
self.log('uploading filename:',filename)
|
|
rdata=await self.api.upload(filename,file_id=file_id)
|
|
self.log('upload result:',rdata)
|
|
if rdata is not None:
|
|
rdata['success']='File uploaded'
|
|
return rdata
|
|
return {'error':'Upload failed'}
|
|
|
|
async def download(self,file_id,output_fn=None):
|
|
self.log('downloading:',file_id)
|
|
file_dat = await self.api.download(file_id)
|
|
self.log('file_dat =',file_dat)
|
|
if not output_fn:
|
|
file_id=file_dat['id']
|
|
file_ext=file_dat['ext']
|
|
output_fn=os.path.join('cache',file_id[:3]+'/'+file_id[3:]+'.'+file_ext)
|
|
|
|
output_dir=os.path.dirname(output_fn)
|
|
if not os.path.exists(output_dir): os.makedirs(output_dir)
|
|
|
|
with open(output_fn,'wb') as of:
|
|
for data_piece in file_dat['parts_data']:
|
|
if data_piece is not None:
|
|
of.write(data_piece)
|
|
|
|
async def post(self, content='', file_id=None, file_ext=None, anonymous=False,channel='world'):
|
|
#timestamp=time.time()
|
|
jsond={}
|
|
#jsond['timestamp']=
|
|
if content: jsond['content']=str(content)
|
|
if file_id: jsond['file_id']=str(file_id)
|
|
if file_ext: jsond['file_ext']=str(file_ext)
|
|
if channel and channel[0]=='@': channel=channel[1:]
|
|
self.log(f'''app.post(
|
|
content={content},
|
|
file_id={file_id},
|
|
file_ext={file_ext},
|
|
anonymous={anonymous},
|
|
channel={channel},
|
|
[username={self.username}]'''
|
|
)
|
|
if not anonymous and self.username:
|
|
jsond['author']=self.username
|
|
|
|
#jsond['channel']=channel
|
|
self.log('posting:',jsond)
|
|
res=await self.api.post(jsond,channel = channel)
|
|
if 'success' in res:
|
|
self.root.change_screen('feed')
|
|
return {'post_id':res['post_id']}
|
|
|
|
|
|
@property
|
|
def keys(self):
|
|
return self.komrade.contacts()
|
|
|
|
async def get_post(self,post_id):
|
|
return self.komrade.read_post()
|
|
|
|
def get_posts(self,uri=b'/inbox/world'):
|
|
return self.komrade.posts()
|
|
|
|
|
|
async def get_channel_posts(self,channel,prefix='inbox'):
|
|
# am I allowed to?
|
|
if not channel in self.keys:
|
|
self.log('!! tsk tsk dont be nosy')
|
|
return
|
|
return await self.get_posts(uri='/'+os.path.join(prefix,channel))
|
|
|
|
async def get_channel_inbox(self,channel):
|
|
return await self.get_channel_posts(channel=channel,prefix='inbox')
|
|
|
|
async def get_channel_outbox(self,channel):
|
|
return await self.get_channel_posts(channel=channel,prefix='outbox')
|
|
|
|
async def get_my_posts(self):
|
|
return await self.persona.read_outbox()
|
|
|
|
|
|
|
|
### SYNCHRONOUS?
|
|
def app_func(self):
|
|
'''This will run both methods asynchronously and then block until they
|
|
are finished
|
|
'''
|
|
# self.other_task = asyncio.ensure_future(self.waste_time_freely())
|
|
# self.other_task = asyncio.ensure_future(self.api.connect_forever())
|
|
|
|
async def run_wrapper():
|
|
# we don't actually need to set asyncio as the lib because it is
|
|
# the default, but it doesn't hurt to be explicit
|
|
await self.async_run() #async_lib='asyncio')
|
|
print('App done')
|
|
# self.other_task.cancel()
|
|
|
|
# return asyncio.gather(run_wrapper(), self.other_task)
|
|
asyncio.run(run_wrapper())
|
|
|
|
|
|
|
|
def open_dialog(self,msg):
|
|
if not hasattr(self,'dialog') or not self.dialog:
|
|
self.dialog = ProgressPopup()
|
|
|
|
# raise Exception(self.dialog, msg)
|
|
self.dialog.text=msg
|
|
self.dialog.open()
|
|
#stop
|
|
|
|
def stat(self,msg,komrade_name='Telephone',pause=False,**y):
|
|
from komrade.app.screens.feed.feed import PostCard
|
|
if not hasattr(self,'msg_dialog') or not self.msg_dialog:
|
|
self.msg_dialog = MessagePopupCard()
|
|
# self.msg_dialog.ids.msg_label.text=msg
|
|
|
|
self.msg_dialog.card = postcard = PostCard({
|
|
'author':komrade_name,
|
|
'author_prefix':'Komrade @',
|
|
'to_name':'me',
|
|
'content':msg,
|
|
'timestamp':time.time(),
|
|
})
|
|
postcard.size_hint=(None,None)
|
|
postcard.size=('600sp','600sp')
|
|
self.msg_dialog.add_widget(postcard)
|
|
|
|
self.msg_dialog.open()
|
|
|
|
def open_msg_dialog(self,msg):
|
|
# from screens.post.post import MessagePopup,ProgressPopup
|
|
if not hasattr(self,'msg_dialog') or not self.msg_dialog:
|
|
self.msg_dialog = MessagePopup()
|
|
self.msg_dialog.ids.msg_label.text=msg
|
|
self.msg_dialog.open()
|
|
|
|
def close_dialog(self):
|
|
if hasattr(self,'dialog'):
|
|
self.dialog.dismiss()
|
|
|
|
def close_msg_dialog(self):
|
|
if hasattr(self,'msg_dialog'):
|
|
self.msg_dialog.remove_widget(self.msg_dialog.card)
|
|
self.msg_dialog.dismiss()
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
loop = asyncio.get_event_loop()
|
|
loop.run_until_complete(MainApp().app_func())
|
|
loop.close()
|
|
|
|
|
|
|
|
|
|
# def main():
|
|
# # start_logger()
|
|
# App = MainApp()
|
|
# App.run()
|
|
|
|
|
|
# if __name__ == '__main__':
|
|
# # loop = asyncio.get_event_loop()
|
|
# # asyncio.set_event_loop(loop)
|
|
# # loop.run_until_complete(main())
|
|
# # loop.close()
|
|
# main()
|