def writer():
testfile = 'Testing' # file with a string
perms = [Permission.WRITE_EXTERNAL_STORAGE, Permission.READ_EXTERNAL_STORAGE]
if check_permissions(perms)!= True:
request_permissions(perms) # get android permissions
exit() # app has to be restarted; permissions will work on 2nd start
try:
Logger.info('Got requested permissions')
ffolder = os.path.join(primary_external_storage_path(),'KT') #folder name
fname = os.path.join(ffolder,'testfile.txt') #file name
log(f'writing to: {fname}')
try:
os.makedirs(ffolder)
with open(fname, 'w') as f: # write testfile
f.write(testfile)
return fname
except Exception as e:
pass
except:
log('could not write to external storage ... missing permissions ?')
class SaveDialog(FloatLayout):
cancel = ObjectProperty(None)
text_input = ObjectProperty(None)
save = ObjectProperty(None)
create_dir = ObjectProperty(None)
dir_prefix = StringProperty(storage.primary_external_storage_path())
def __init__(self, **kwargs):
super(SaveDialog, self).__init__(**kwargs)
def cancel_folder(self):
self._popup.dismiss()
def create_folder(self, path):
os.mkdir(path)
self.dir_prefix = path
self.cancel_folder()
def prompt_folder(self, path):
option = NewFolderDialog(create=self.create_folder,
cancel=self.cancel_folder,
path=path)
self._popup = Popup(title="New Folder",
content=option,
size_hint=(1, .3))
self._popup.open()
def get_drives():
drives = []
if platform == 'win':
for path in ['Desktop', 'Documents', 'Pictures']:
drives.append(
(os.path.expanduser(u'~') + os.path.sep + path + os.path.sep,
path))
bitmask = windll.kernel32.GetLogicalDrives()
for letter in string.ascii_uppercase:
if bitmask & 1:
name = create_unicode_buffer(64)
# get name of the drive
drive = letter + u':'
windll.kernel32.GetVolumeInformationW(drive + os.path.sep,
name, 64, None, None,
None, None, 0)
drive_name = drive
if name.value:
drive_name = drive_name + '(' + name.value + ')'
drives.append((drive + os.path.sep, drive_name))
bitmask >>= 1
elif platform == 'linux':
drives.append((os.path.sep, os.path.sep))
drives.append((os.path.expanduser(u'~') + os.path.sep, 'Home'))
drives.append(
(os.path.sep + u'mnt' + os.path.sep, os.path.sep + u'mnt'))
places = (os.path.sep + u'mnt' + os.path.sep, os.path.sep + u'media')
for place in places:
if os.path.isdir(place):
for directory in next(os.walk(place))[1]:
drives.append(
(place + os.path.sep + directory + os.path.sep,
directory))
elif platform == 'macosx' or platform == 'ios':
drives.append((os.path.expanduser(u'~') + os.path.sep, 'Home'))
vol = os.path.sep + u'Volume'
if os.path.isdir(vol):
for drive in next(os.walk(vol))[1]:
drives.append((vol + os.path.sep + drive + os.path.sep, drive))
elif platform == 'android':
paths = [('/', 'Root'), ('/storage', 'Mounted Storage')]
from android.storage import primary_external_storage_path
primary_ext_storage = primary_external_storage_path()
if primary_ext_storage:
paths.append((primary_ext_storage, 'Primary Storage'))
from android.storage import secondary_external_storage_path
secondary_ext_storage = secondary_external_storage_path()
if secondary_ext_storage:
paths.append((secondary_ext_storage, 'Secondary Storage'))
for path in paths:
realpath = os.path.realpath(path[0]) + os.path.sep
if os.path.exists(realpath):
drives.append((realpath, path[1]))
return drives
def get_downloads_dir():
"""
Return the path to the user's downloads dir.
"""
if PLATFORM == 'android':
return os.path.join(primary_external_storage_path(),
Environment.DIRECTORY_DOWNLOADS)
else:
return os.getcwd()
def file_manager_open(self):
if platform == 'android':
request_permissions([
Permission.WRITE_EXTERNAL_STORAGE,
Permission.READ_EXTERNAL_STORAGE
])
SD_CARD = primary_external_storage_path()
self.file_manager.show(SD_CARD)
else:
self.file_manager.show("/")
def getpaths():
if platform == 'android':
from android.storage import app_storage_path
app_storage = app_storage_path()
from android.storage import primary_external_storage_path
internal = primary_external_storage_path()
from android.storage import secondary_external_storage_path
external = secondary_external_storage_path()
return app_storage, internal, external
if platform == 'linux' or platform == 'win':
internal_storage = str(Path.home())
return None, internal_storage, None
def load_dialog(self):
start_path = os.path.dirname(os.path.abspath(__file__))
if 'android' in kivy.utils.platform:
start_path = primary_external_storage_path()
elif 'linux' in kivy.utils.platform:
start_path = str(Path.home())
content = LoadDialog(load=self.load_file,
cancel=self.dismiss_popup,
start_path=start_path)
self._popup = Popup(title="Load file",
content=content,
size_hint=(0.9, 0.9))
self._popup.open()
def main(say, widget):
for i in trigger:
if i in say:
toSpeak = "Я сделал снимок экрана."
storage = primary_external_storage_path()
plyer.screenshot(file_path=f"{storage}/Pictures/")
break
else:
toSpeak = ""
if toSpeak != "":
speak.speak(toSpeak, widget)
return toSpeak
def video_start(self):
if not self.video_is_recording:
self.preview_view.performClick()
context = PythonActivity.mActivity.getApplicationContext()
dt = datetime.datetime.now()
today = dt.strftime("%Y_%m_%d")
name = dt.strftime("%H_%M_%S") + '.mp4'
if self.private or api_version < 29:
if self.private:
root = app_storage_path()
else:
root = primary_external_storage_path()
if not root:
self.callback("ERROR: No external storage")
return
dir = join(root, Environment.DIRECTORY_DCIM)
if not exists(dir):
mkdir(dir)
if not self.private:
dir = join(dir,self.app_name())
if not exists(dir):
mkdir(dir)
dir = join(dir,today)
if not exists(dir):
mkdir(dir)
self.filepath = join(dir,name)
self.name_pipe.append(self.filepath)
self.videofile = File(self.filepath)
self.vcf = VideoCaptureOutputFileOptionsBuilder(self.videofile).build()
else:
self.cr = PythonActivity.mActivity.getContentResolver()
collection = MediaStoreVideoMedia.EXTERNAL_CONTENT_URI
self.cv = ContentValues()
self.cv.put(MediaStoreMediaColumns.DISPLAY_NAME, name)
self.cv.put(MediaStoreMediaColumns.MIME_TYPE, "video/mp4")
self.cv.put(MediaStoreMediaColumns.RELATIVE_PATH,
join(Environment.DIRECTORY_DCIM, self.app_name(),today))
self.vcf = VideoCaptureOutputFileOptionsBuilder(self.cr,
collection,
self.cv).build()
if api_version < 28:
self.te = ContextCompat.getMainExecutor(context)
else:
self.te = context.getMainExecutor()
self.wrapper = CallbackWrapper(self.callback_wrapper)
self.vsc = VideoSavedCallback(self.wrapper)
self.imageCapture.startRecording(self.vcf,self.te,self.vsc)
self.video_is_recording = not self.video_is_recording
def playFromDir():
global musicIsPlayed
storage = primary_external_storage_path()
playlist = os.listdir(f"{storage}/Music/")
for file in playlist:
if os.path.isdir(f"{storage}/Music/{file}"):
playlist.remove(file)
if musicIsPlayed:
mPlayer.stop()
mPlayer.reset()
mPlayer.setDataSource(f'{storage}/Music/{random.choice(playlist)}')
mPlayer.prepare()
mPlayer.start()
else:
mPlayer.setDataSource(f'{storage}/Music/{random.choice(playlist)}')
mPlayer.prepare()
mPlayer.start()
musicIsPlayed = True
def select_zip(self, *args):
if platform == 'android':
if check_permission(
Permission.WRITE_EXTERNAL_STORAGE
) == False: # check permission takes str not a list
request_permission(Permission.WRITE_EXTERNAL_STORAGE)
request_permission(Permission.READ_EXTERNAL_STORAGE)
request_permission(Permission.MANAGE_EXTERNAL_STORAGE)
request_permission(Permission.MANAGE_DOCUMENTS)
#request_permisssion takes str and request_permissions takes list
return
self.secondary_ext_storage = secondary_external_storage_path()
self.primary_ext_storage = primary_external_storage_path()
self.app_path = app_storage_path()
Logger.debug(" Storages are \n" + str(self.app_path) + "\n" +
str(self.primary_ext_storage))
else:
#self.root.ids.status_label.text = " I am not running in android "
pass
self.file_manager_open()
from PIL import Image
from android import activity, mActivity
from android.permissions import request_permissions, Permission
from android.storage import primary_external_storage_path
request_permissions([Permission.CAMERA, Permission.READ_EXTERNAL_STORAGE])
from kivy.logger import Logger
from kivy.config import Config
Config.set('kivy', 'log_level', 'debug')
Config.set('kivy', 'log_dir', 'logs')
Config.set('kivy', 'log_name', 'kivy_%y-%m-%d_%_.txt')
Config.set('kivy', 'log_enable', 1)
Config.write()
Logger.debug("DEBUG: primary_external_storage_path")
Logger.debug("DEBUG: %s", primary_external_storage_path())
Intent = autoclass('android.content.Intent')
MediaStore = autoclass('android.provider.MediaStore')
Environment = autoclass('android.os.Environment')
Context = autoclass("android.content.Context")
FileProvider = autoclass('android.support.v4.content.FileProvider')
PythonActivity = autoclass("org.kivy.android.PythonActivity").mActivity
class TakePictureApp(App):
def take_picture(self):
def create_img_file():
File = autoclass('java.io.File')
storageDir = Context.getExternalFilesDir(
Environment.DIRECTORY_PICTURES)
def file_manager_open(self):
from android.storage import primary_external_storage_path # todo
primary_ext_storage = primary_external_storage_path() # todo
self.file_manager.show("/") # todo
self.file_manager.show(primary_ext_storage) # output manager to the screen
self.manager_open = True
def exportDeck(self, btn):
if platform == 'android':
request_permissions([
Permission.WRITE_EXTERNAL_STORAGE,
Permission.READ_EXTERNAL_STORAGE
])
SD_CARD = primary_external_storage_path()
folder = os.path.join(SD_CARD, 'Anki Deck Export')
else:
folder = 'Anki Deck Export'
if not os.path.exists(folder):
os.makedirs(folder)
# imported file name
data_filename = self.sm.ids.main_screen_id.ids.path_selected_label.text
# title
anki_deck_title = self.sm.ids.export_screen_id.ids.tf_deck_title.text
# model
anki_model_name = self.sm.ids.export_screen_id.ids.tf_deck_model.text
deck_name = anki_deck_title + "_Export_" + ".apkg"
if platform == 'android':
# deck file
deck_filename = os.path.join(SD_CARD, 'Anki Deck Export',
deck_name)
else:
deck_filename = os.path.join('Anki Deck Export', deck_name)
model_id = random.randrange(1 << 30, 1 << 31)
flag = False
front = "<div>{{" + self.dynamic_ids["Field0"].text + "}}</div>"
back = ""
self.fields = []
for field in self.dynamic_ids:
self.fields.append({"name": self.dynamic_ids[field].text})
back += "<div>{{" + self.dynamic_ids[field].text + "}}</div>\n"
for field in self.dynamic_ids:
if len(self.dynamic_ids[field].text) > 0:
flag = True
else:
flag = False
style = """
.card {
font-family: arial;
font-size: 20px;
text-align: center;
color: black;
background-color: white;
}
"""
try:
if flag:
anki_model = genanki.Model(
model_id,
anki_model_name,
fields=self.fields,
templates=[
{
"name": "Card 1",
"qfmt": front,
"afmt": back,
},
],
css=style,
)
anki_notes = []
with open(data_filename, "r", encoding="utf-8") as csv_file:
csv_reader = csv.reader(csv_file, delimiter=self.delim)
for row in csv_reader:
flds = []
for i in range(len(row)):
flds.append(row[i])
anki_note = genanki.Note(
model=anki_model,
fields=flds,
)
anki_notes.append(anki_note)
#random.shuffle(anki_notes)
anki_deck = genanki.Deck(model_id, anki_deck_title)
anki_package = genanki.Package(anki_deck)
for anki_note in anki_notes:
anki_deck.add_note(anki_note)
anki_package.write_to_file(deck_filename)
toast("Deck generated with {} flashcards".format(
len(anki_deck.notes)))
else:
toast("Fields are empty!")
except:
toast("Deck Creation Failed!")
print(traceback.print_exc())
#!/usr/bin/python3
# coding: utf8
from kivy.app import App
from kivy.factory import Factory
from kivy.logger import Logger
from kivy.storage.jsonstore import JsonStore
from gen_pdf import motifs_courts, generer_pdf
import os.path
from kivy import platform
if platform == 'android':
from android.permissions import request_permissions, Permission
from android.storage import primary_external_storage_path, app_storage_path
data_dir = app_storage_path()
user_dir = primary_external_storage_path()
else:
from pathlib import Path
data_dir = os.path.dirname(os.path.abspath(__file__))
user_dir = Path.home()
import locale
locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')
__version__ = "0.9.9"
class AttgenApp(App):
data = {
'nom': '',
'prenom': '',
'date_naissance': '',
'lieu_naissance': '',
'adresse': '',
def __init__(self, **kwargs):
super(box, self).__init__(**kwargs)
self.main_box = BoxLayout(size=Window.size)
self.main_box.orientation = 'vertical'
self.anim_type = 'slide_above_simple'
###############################################################################3
act_current_dir = os.getcwd()
#os.chdir(r'/home/nagendra/test_folder')
os.chdir(r'/storage/emulated/0/New kivy/My_app/New_music_code')
current_dir = os.getcwd()
os.chdir(act_current_dir)
print('current_dirrrr = ', current_dir)
#######################################################################
self.lyt_image = main_lyt_image(self)
self.nav_lyt = navigator_lyt(self,
self.main_box) # for navigation layout
self.nav_lyt.bind(on_press=partial(open_filemanager, music_app,
self.main_box, current_dir))
self.nav_lyt.bind(on_release=lambda x: self.toggle_nav_drawer())
####################################################################
gridlayout = GridLayout(cols=1, size_hint_y=None, spacing=1)
gridlayout.bind(minimum_height=gridlayout.setter('height'))
##################################################################33#########
print('current_di = ', current_dir)
index = 0
## r'/storage/emulated/0/New kivy/My_app/New_music_code/songs/'
SD_CARD = primary_external_storage_path()
request_permissions([
Permission.READ_EXTERNAL_STORAGE, Permission.WRITE_EXTERNAL_STORAGE
])
for dirpath, dir_name, filename in os.walk(SD_CARD):
##print('dir_pathh = ',dirpath)
for fn in glob(dirpath + '/*.mp3'):
print('fn_list= ', fn)
# song_text = fn.split('/')[-1:][0][:-4]
#################################################
song_name, btn_image, song_length = data_extract(fn)
if (float(song_length) < 100.0):
continue
print('son_len = ', str(song_length))
###################################################
song_button = tbtn_new()
song_button.bind(
on_press=partial(self.gonext, index, self.main_box))
song_button.text = song_name
songlist[index] = [fn, song_button]
# song_button.canvas.before.children[0].rgba = [1,1,1,0.15] # Background color of button
##################################################
song_btn_image(song_button, btn_image) ## Image of button
####################################################################
gridlayout.add_widget(song_button)
index += 1
#txtfile.close()
scrollview = ScrollView()
scrollview.add_widget(gridlayout)
self.main_box.add_widget(scrollview)
self.add_widget(self.main_box)
import logging
import os
from datetime import date, time
from openpyxl import load_workbook
from kivy.uix.recycleview import RecycleView
from kivy.properties import ObjectProperty
from kivy.lang import Builder
from kivy.app import App
from android.storage import primary_external_storage_path
primary_ext_storage = primary_external_storage_path()
from android.permissions import request_permissions, Permission
request_permissions([Permission.WRITE_EXTERNAL_STORAGE])
class IndividualEdit(RecycleView):
""" The next page to edit individual sheets """
sm = ObjectProperty(None)
def init_data(self, *args):
app = App.get_running_app()
self.data = []
for i in range(5, 12):
if app.sheet_editors[
app.circle].sheet[f"B{i}"].value.title() != "Total":
self.data.append({
"l1":
app.sheet_editors[app.circle].sheet[f"B{i}"].value or "",
"l2":
app.sheet_editors[app.circle].sheet[f"C{i}"].value or "",
class SmartBricksApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
Window.bind(on_keyboard=self.events)
self.manager_open = False
self.file_manager = MDFileManager(exit_manager=self.exit_manager,
select_path=self.select_path,
previous=True,
ext=['jpeg', 'png', 'jpg'])
#self.menu_2 = self.create_menu("Button dots", self.root.ids.toolbar.ids.button_2)
#print('HEREEEEEEE!!!!', self.root)
#cm = CustomToolbar
try:
request_permissions([
Permission.WRITE_EXTERNAL_STORAGE,
Permission.READ_EXTERNAL_STORAGE
])
except NameError:
pass
def dropdown(self, id):
self.menu_2 = self.create_menu("Button dots", id)
self.menu_2.open()
def create_menu(self, instance):
menu_items = [
{
"right_content_cls": RightContentCls(
#text=f"R", icon="apple-keyboard-command",
),
"icon": "apple-keyboard-command",
"text": text,
} for text in ('RENAME', 'DELETE')
]
return MDDropdownMenu(caller=instance, items=menu_items, width_mult=4)
def build(self):
#Window.bind(on_keyboard=self.key_input)
self.screen = Builder.load_file("main.kv")
return self.screen
def on_pause(self):
return True
#def key_input(self, window, key, scancode, codepoint, modifier):
# if key == 27:
# return True # override the default behaviour
# else: # the key now does nothing
# return False
#settings_path = app_storage_path()
path = os.getcwd()
df = pd.read_csv('%s/legoKeys.cvs' % (path), sep='\t')
try:
SD_CARD = primary_external_storage_path() + '/' + 'DCIM/Camera'
out_dir = '%s/smartbricks_outputs/' % (primary_external_storage_path())
print('ANDROID mmodules loaded...')
except NameError:
print('ANDROID modules failed...')
SD_CARD = '/home/omar/Pictures'
out_dir = '%s/myproj_out/' % (path)
pass
isdir = os.path.isdir(out_dir)
def plist(self):
if self.isdir:
plist_ = os.listdir(self.out_dir)
else:
os.mkdir(self.out_dir)
plist_ = None
return plist_
custom_sheet = None
def callback_for_menu_items(self, *args):
toast(args[0])
def openScreen(self, itemdrawer):
self.openScreenName(itemdrawer.target)
self.root.ids.nav_drawer.set_state("close")
def openScreenName(self, screenName):
self.root.ids.screen_manager.current = screenName
def ifproject(self):
print('PLIST!!!!!!!!!', self.plist())
print('PLIST TYPE!!!!!!!!!', type(self.plist()))
if ((self.isdir) & (self.plist() is not None)):
#clear widgets if any previously load to avoid staking of color palettes between projects
self.root.ids.grid_list.clear_widgets()
#self.root.ids.grid_list.remove_widget(self.root.ids.grid_list)
self.openScreenName('projects')
#if ((self.isdir) & (self.plist is not None)):
for dir_ in self.plist():
self.root.ids.grid_list.add_widget(
CustomSmartTileWithLabel(
source=self.out_dir + dir_ + '/all.jpeg',
text="[size=32]%s[/size]" % (dir_)))
else:
self.callback_for_menu_items(
'No projects saved yet. Select START to start a new project.')
def chooseproject(self, img_source):
#clear widgets if any previously load to avoid staking of color palettes between projects
self.root.ids.content_drawer.ids.md_list.clear_widgets()
self.root.ids.image.source = img_source
self.openScreenName('main')
self.img_path = os.path.dirname(img_source)
tab = np.load(self.img_path + '/table.npz')
self.tab = tab['data']
row_data = []
n2x2, n2x1, n1x1 = 0, 0, 0
for num, i in enumerate(self.tab.T[0][:-1]):
if i == '0.0_0.0_0.0': continue
R, G, B = i.split("_")
R, G, B = [np.int(np.float(j)) for j in [R, G, B]]
mask = (self.df['R'] == R) & (self.df['G'] == G) & (self.df['B']
== B)
Nbrick, color_name = self.df['LEGO No.'][mask].item(
), self.df['Color'][mask].item()
#print(R,G,B, Nbrick, color_name)
#
self.root.ids.content_drawer.ids.md_list.add_widget(
CustomMDIconButton(color=(R / 256, G / 256, B / 256, 1),
text=color_name,
text_color=(1, 0, 0, 1),
icon='checkbox-blank-circle-outline'))
n2x2 += int(self.tab.T[1][num])
n2x1 += int(self.tab.T[2][num])
n1x1 += int(self.tab.T[3][num])
row_data.append(
(color_name, self.tab.T[1][num], self.tab.T[2][num],
self.tab.T[3][num], int(self.tab.T[1][num]) +
int(self.tab.T[2][num]) + int(self.tab.T[3][num])))
row_data.append(('Total', n2x2, n2x1, n1x1, n2x2 + n2x1 + n1x1))
#if len(row_data) > 10: pagination = True
#else: pagination = False
self.data_tables = MDDataTable(
size_hint=(0.9, 0.6),
rows_num=20,
use_pagination=True if len(row_data) > 20 else False,
check=False,
column_data=[("Color", dp(40)), ("2x2", dp(10)), ("2x1", dp(10)),
("1x1", dp(10)), ("All", dp(10))],
row_data=row_data,
)
self.root.ids.content_drawer.ids.md_list.add_widget(
CustomMDIconButton(
color=self.theme_cls.primary_color,
text='All',
icon='checkbox-blank-circle-outline',
#text_color=(R/256,G/256,B/256,1),
#icon='checkbox-marked-circle'
))
self.root.ids.content_drawer.ids.md_list.add_widget(
CustomMDIconButton(color=self.theme_cls.primary_color,
text='Original',
icon=''))
keep = self.tab.T[0] == 'total'
b2x2 = self.root.ids.brick_2x2
b2x1 = self.root.ids.brick_2x1
b1x1 = self.root.ids.brick_1x1
for num, brick, brickLab in zip([1, 2, 3], [b2x2, b2x1, b1x1],
['2x2', '2x1', '1x1']):
brick.text = brickLab + ': ' + self.tab.T[num][keep][0]
def choose_palette(self, img_bg_color, text, id):
self.root.ids.palette_toolbar.md_bg_color = img_bg_color
self.img_path = os.path.dirname(self.root.ids.image.source)
#R,G,B = np.float(img_bg_color[0]*256), np.float(img_bg_color[1]*256), np.float(img_bg_color[2]*256)
R, G, B = np.int(img_bg_color[0] * 256), np.int(
img_bg_color[1] * 256), np.int(img_bg_color[2] * 256)
mean = np.mean([R, G, B])
#print(R,G,B)
#self.root.ids.image.parent.remove_widget(self.root.ids.image)
if text not in ['All', 'Original']:
self.root.ids.image.clear_widgets()
self.root.ids.image.source = self.img_path + '/%s_%s_%s.zip' % (
str(R), str(G), str(B))
else:
self.root.ids.image.source = self.img_path + '/%s.jpeg' % (
text.lower())
print('SOURCE!!!!!!!', self.root.ids.image.source)
print('TEXT!!!!!!!', text)
id.icon = 'checkbox-marked-circle'
#Get bricks counts
tab = np.load(self.img_path + '/table.npz')
self.tab = tab['data']
if text not in ['All', 'Original']:
keep = self.tab.T[0] == '%s_%s_%s' % (str(R), str(G), str(B))
else:
keep = self.tab.T[0] == 'total'
b2x2 = self.root.ids.brick_2x2
b2x1 = self.root.ids.brick_2x1
b1x1 = self.root.ids.brick_1x1
if mean > 180:
test_color = [0, 0, 0, 1] #black
invert = False
else:
test_color = [1, 1, 1, 1] #withe
invert = True
id.text_color = test_color
for num, brick, brickLab in zip([1, 2, 3], [b2x2, b2x1, b1x1],
['2x2', '2x1', '1x1']):
brick.text = brickLab + ': ' + self.tab.T[num][keep][0]
brick.text_color = test_color
#print(brick.text_color)
b2x2_i = self.root.ids.brick_2x2_icon
b2x1_i = self.root.ids.brick_2x1_icon
b1x1_i = self.root.ids.brick_1x1_icon
for num, brick, brickLab in zip([1, 2, 3], [b2x2_i, b2x1_i, b1x1_i],
['2x2', '2x1', '1x1']):
#print('MAIN PATH:', self.path)
if invert:
brick.icon = "%s/images/%s_invert.jpg" % (self.path, brickLab)
else:
brick.icon = "%s/images/%s.jpg" % (self.path, brickLab)
#self.root.ids.brick_2x2.text = '2x2: '+self.tab.T[1][keep][0]
#self.root.ids.brick_2x1.text = '2x1: '+self.tab.T[2][keep][0]
#self.root.ids.brick_1x1.text = '1x1: '+self.tab.T[3][keep][0]
#print(mean, test_color, self.root.ids.brick_2x2.text_color)
#self.root.ids.brick_2x2.text_color=test_color
#if invert: self.root.ids.brick_2x2_icon.icon="/home/omar/myproj/SmartBricks/2x2_invert.jpg"
#else: self.root.ids.brick_2x2_icon.icon="/home/omar/myproj/SmartBricks/2x2.jpg"
#print(self.root.ids.brick_2x2.text_color)
#def test(self, R, G, B):
# return R,G,B,1
def callback_mosaic_size(self, instance, value):
toast('mosaic size: %s' % (value))
self.mosaic_size_val = value
def callback_mosaic_color(self, instance, value):
toast('mosaic colors: %s' % (value))
self.mosaic_color_val = value
def callback_mosaic_name(self, instance, value):
toast('mosaic name: %s' % (value))
self.mosaic_name = value
def show_alert_dialog(self, name):
if not self.dialog:
self.dialog = MDDialog(
title="Replace existing project?",
text=
"Project '%s' already exists. Do you want to replace existing project?"
% (name),
buttons=[
MDFlatButton(text="CANCEL",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.dialog.dismiss()),
MDFlatButton(
text="ACCEPT",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.show_dialog_progress()),
],
)
else:
self.dialog.dismiss()
self.dialog.open()
def create_mosaic(self):
print('LOWSIZE --------', type(self.mosaic_size_val))
print('NCOLORS --------', type(self.mosaic_color_val))
print('OUTDIR --------', type(self.root.ids.project_name.text))
if (self.mosaic_size_val is
None) or (self.mosaic_color_val is
None) or (self.root.ids.project_name.text == ''):
ttext = 'Define mosaic input values'
if (self.mosaic_size_val is None): ttext += ', lower size'
if (self.mosaic_color_val is None): ttext += ', colors'
if (self.root.ids.project_name.text == ''):
ttext += ', project name'
print('TEXT ------ ', ttext)
toast(ttext)
#elif
#elif (if not self.root.ids.project_name.text):
# toast('Choose a project name first')
else:
#print(self.root.ids.setup_image.source)
#print(int(self.mosaic_size_val))
#print(int(self.mosaic_color_val))
#print(self.root.ids.project_name.text)
#print(self.out_dir+self.root.ids.project_name.text)
self.imgpath = str(self.root.ids.setup_image.source)
self.Ncolors = np.int(self.mosaic_color_val)
self.lowsize = np.int(self.mosaic_size_val)
self.outdir = str(self.out_dir + self.root.ids.project_name.text)
for i in [self.imgpath, self.Ncolors, self.lowsize, self.outdir]:
print(i, type(i))
if (self.plist() is not None):
if (self.root.ids.project_name.text in self.plist()):
print('project name already exist...')
self.show_alert_dialog(
name=self.root.ids.project_name.text)
else:
self.show_dialog_progress()
else:
self.show_dialog_progress()
def show_dialog_progress(self):
#if not self.dialog2:
self.dialog2 = MDDialog(
title="Creating mosaic. Please wait.",
type="custom",
#text="Creating mosaic. Please wait.",
content_cls=progress_bar(), #self.pb,
on_open=self.run_mosaic
#on_open=self.puopen)
#on_open=self.run_mosaic(imgpath=imgpath, Ncolors=Ncolors, lowsize=lowsize, outdir=outdir)
)
self.dialog2.open()
if self.dialog: self.dialog.dismiss()
#self.dialog2.bind(on_open=self.run_mosaic)
#self.run_mosaic
#def run_mosaic(self, imgpath=None, Ncolors=None, lowsize=None, outdir=None):
def run_mosaic(self, instance):
#clear widgets if any previously load to avoid staking of color palettes between projects
#self.pb.load_bar.clear_widgets()
self.pb = progress_bar()
#self.pb.load_bar.parent.remove_widget(self.pb.load_bar)
self.pb.load_bar.value = 0
#print(self.pb.load_bar.value)
#Nmax = np.int(self.mosaic_color_val) #+ 3
start = time.time()
SB = SmartBricks(imgpath=self.imgpath,
Ncolors=self.Ncolors,
lowsize=self.lowsize,
outdir=self.outdir)
#print(SB.img)
#print(SB.res1x1)
#SB.saveProj()
end = time.time()
print('Total run time #1: %f sec' % (end - start))
print('point size', SB.size)
import matplotlib.pyplot as plt
ispathdir = os.path.isdir(self.outdir)
if not ispathdir: os.makedirs(self.outdir, exist_ok=True)
else:
files = os.listdir(self.outdir)
#print(self.outdir)
for f in files:
os.remove(self.outdir + '/' + f)
start = time.time()
#lmax = 10
if SB.w > SB.h: x_size, y_size = SB.lmax, SB.h * SB.lmax / SB.w
else: x_size, y_size = SB.w * SB.lmax / SB.h, SB.lmax
fig = plt.figure(figsize=(x_size, y_size))
#fig = plt.figure(figsize=(12,12))
ax = plt.gca()
SB.bricksCanvas(img=SB.img,
fig=fig,
ax=ax,
RGB=None,
res2x2=SB.res2x2,
res2x1=SB.res2x1,
res1x1=SB.res1x1)
figcvs = fig
figall = fig
#figoriginal = fig.copy
#paletteLego = SB.palette(SB.img)
#palette_flat = SB.imgFlat(paletteLego)
Nmax = len(SB.palette_flat)
self.pb.load_bar.max = Nmax
table = []
#for num, pal in enumerate(palette_flat):
for i in range(Nmax):
print(self.pb.load_bar.value)
pal = SB.palette_flat[i]
N2x2, N2x1, N1x1 = SB.makeGiff(
img=SB.img,
RGB=pal,
idxs=[SB.res2x2[2], SB.res2x1[2], SB.res1x1[2]],
pathdir=self.outdir,
fig=figcvs,
ax=ax)
r, g, b = pal
color = '%s_%s_%s' % (r, g, b)
table.append([color, N2x2, N2x1, N1x1])
self.pb.load_bar.value = i + 1
#self.value99 = i+1
t = np.array(table)
N2x2total = np.sum(t[:, 1].astype(int))
N2x1total = np.sum(t[:, 2].astype(int))
N1x1total = np.sum(t[:, 3].astype(int))
table.append(['total', N2x2total, N2x1total, N1x1total])
end = time.time()
print('Total run time #2: %f sec' % (end - start))
start = time.time()
figall.subplots_adjust(left=SB.left,
bottom=SB.bottom,
right=SB.right,
top=SB.top,
wspace=None,
hspace=None)
ax = figall.add_subplot(111)
ax.imshow(SB.img)
#True if testing App from PC.
if SB.frompc:
figall.savefig('%s/all.jpeg' % (self.outdir),
bbox_inches='tight',
pad_inches=0)
else:
buffer = io.BytesIO()
canvas = plt.get_current_fig_manager().canvas
canvas.draw()
pil_image = PIL.Image.frombytes('RGB', canvas.get_width_height(),
canvas.tostring_rgb())
pil_image.save('%s/all.jpeg' % (self.outdir), 'JPEG')
fig0 = plt.figure(figsize=(x_size, y_size))
fig0.subplots_adjust(left=SB.left,
bottom=SB.bottom,
right=SB.right,
top=SB.top,
wspace=None,
hspace=None)
ax = plt.gca()
ax = fig0.add_subplot(111)
ax.imshow(SB.img_original)
if SB.frompc:
fig0.savefig('%s/original.jpeg' % (self.outdir),
bbox_inches='tight',
pad_inches=0)
else:
buffer = io.BytesIO()
canvas = plt.get_current_fig_manager().canvas
canvas.draw()
pil_image = PIL.Image.frombytes('RGB', canvas.get_width_height(),
canvas.tostring_rgb())
pil_image.save('%s/original.jpeg' % (self.outdir), 'JPEG')
#ax = figall.add_subplot(111)
#ax.imshow(SB.img)
#figall.savefig('%s/all.jpeg' %(self.outdir), bbox_inches = 'tight', pad_inches = 0)
#fig0 = plt.figure(figsize=(12,12))
#ax = fig0.add_subplot(111)
#plt.imshow(SB.img_original)
#fig0.savefig('%s/original.jpeg' %(self.outdir), bbox_inches = 'tight', pad_inches = 0)
np.savez_compressed('%s/table' % (self.outdir), data=table)
end = time.time()
print('Total run time #3: %f sec' % (end - start))
if Nmax == self.pb.load_bar.value:
self.dialog2.dismiss()
#SmartBricks(imgpath=self.imgpath, Ncolors=self.Ncolors, lowsize=self.lowsize, outdir=self.outdir).saveProj(self.pb.load_bar.value)
self.chooseproject(self.outdir + '/all.jpeg')
def next(self, dt):
#if self.times == 0:
#self.run_mosaic
# SmartBricks(imgpath=self.imgpath, Ncolors=self.Ncolors, lowsize=self.lowsize, outdir=self.outdir).saveProj()
# self.times = 1
if os.path.exists(self.outdir):
#self.value99 += 1
print(self.pb.load_bar.value)
Nmax = np.int(self.mosaic_color_val) + 3
self.pb.load_bar.max = Nmax
Ncurrent = len(
os.listdir(str(self.out_dir +
self.root.ids.project_name.text)))
print(self.pb.load_bar.value, self.pb.load_bar.max, Ncurrent)
#print(self.pb.load_bar.value, self.pb.load_bar.max)
if self.pb.load_bar.value >= Nmax:
return False
else:
self.pb.load_bar.value = Ncurrent
#self.pb.load_bar.value = self.value99
else:
print('PATH DOES NOT EXIST YET!')
#print(self.times)
def puopen(self, instance):
#self.times = 0
Clock.schedule_interval(self.next, 1 / 25)
#self.run_mosaic
def on_start(self):
self.imgpath = None
self.Ncolors = None
self.lowsize = None
self.outdir = None
self.mosaic_size_val = None
self.mosaic_color_val = None
self.mosaic_name = None
self.dialog = None
self.dialog2 = None
self.value99 = 0
#self.pb = progress_bar()
self.menu_2 = self.create_menu(self.root.ids.toolbar)
self.root.ids.avatar.source = '%s/images/logo.zip' % (self.path)
self.root.ids.brick_2x2_icon.icon = "%s/images/%s.jpg" % (self.path,
'2x2')
self.root.ids.brick_2x1_icon.icon = "%s/images/%s.jpg" % (self.path,
'2x1')
self.root.ids.brick_1x1_icon.icon = "%s/images/%s.jpg" % (self.path,
'1x1')
for i in np.arange(8, 72, 8):
self.root.ids.mosaic_size.add_widget(
CustomMDChip(label='%s' % (str(i)),
cb=self.callback_mosaic_size,
icon='grid'))
for i in np.arange(2, 18, 2):
self.root.ids.mosaic_colors.add_widget(
CustomMDChip(label=str(i),
cb=self.callback_mosaic_color,
icon='palette'))
#print(self.custbutt.palette.md_bg_color)
#self.root.ids.content_drawer.ids.palette.md_bg_color = (i/100,i/10,0,1)
#md_bg_color=(1,0,0,1)
#
# self.root.ids.content_drawer.ids.md_list.add_widget(
# ItemDrawer(target="screen1", text="Screen 1",
# icon="home-circle-outline",
# on_release=self.openScreen)
# )
# self.root.ids.content_drawer.ids.md_list.add_widget(
# ItemDrawer(target="screen2", text="Screen 2",
# icon="settings-outline",
# on_release=self.openScreen)
# )
def custom_bottom_sheet(self):
self.custom_sheet = MDCustomBottomSheet(
screen=Factory.ContentCustomSheet())
self.custom_sheet.open()
def show_gallery(self):
self.openScreenName('camera')
types = ('*.png', '*.jpeg', '*.jpg') # the tuple of file types
files_grabbed = []
for files in types:
files_grabbed.extend(glob.glob(os.path.join(self.SD_CARD, files)))
files_grabbed.sort(key=os.path.getmtime)
files_grabbed.reverse()
for file in files_grabbed[:20]:
self.root.ids.grid_list_camera.add_widget(
CustomSmartTileWithLabelGallery(source=file,
text="[size=18]%s[/size]" %
(os.path.basename(file))))
def file_manager_open(self):
#self.file_manager.show('/home/omar/Pictures') # output manager to the screen
#self.file_manager.show(self.settings_path)
self.file_manager.show(self.SD_CARD)
self.manager_open = True
def select_path(self, path):
'''It will be called when you click on the file name
or the catalog selection button.
:type path: str;
:param path: path to the selected directory or file;
'''
try:
self.exit_manager()
except:
pass
self.openScreenName('setup')
self.root.ids.setup_image.source = path
toast(path)
def exit_manager(self, *args):
'''Called when the user reaches the root of the directory tree.'''
self.manager_open = False
self.file_manager.close()
def show_dialog_eddit(self):
if self.dialog:
self.dialog.dismiss()
#if not self.dialog2:
self.dialog = MDDialog(
title="Eddit project?",
text="Make a new project with same image.",
buttons=[
MDFlatButton(text="CANCEL",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.dialog.dismiss()),
MDFlatButton(text="ACCEPT",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.eddit_project()),
])
self.dialog.open()
def eddit_project(self):
#self.img_path = os.path.dirname(self.root.ids.image.source)
img_path = self.img_path + '/original.jpeg'
self.openScreenName('setup')
if self.dialog: self.dialog.dismiss()
self.root.ids.setup_image.source = img_path
toast(img_path)
def events(self, instance, keyboard, keycode, text, modifiers):
'''Called when buttons are pressed on the mobile device.'''
if keyboard in (1001, 27):
if self.manager_open:
self.file_manager.back()
return True
def goto_table(self):
#self.openScreenName('mosaic_details')
self.data_tables.open(self.root.ids.details)
def back_main(self):
self.data_tables.dismiss()
self.openScreenName('main')
def show_dialog_buy(self):
if self.dialog:
self.dialog.dismiss()
#if not self.dialog2:
self.dialog = MDDialog(
title="Cooming Soon",
text=
"Apologies, SmartBricks does not deliver yet. We are working to deliver your favourite mosaic to you. Are you interested in buying? ",
buttons=[
MDFlatButton(text="NO",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.dialog.dismiss()),
MDFlatButton(text="YES",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.dialog.dismiss()),
])
self.dialog.open()
def show_dialog_empty(self):
if self.dialog:
self.dialog.dismiss()
#if not self.dialog2:
self.dialog = MDDialog(
title="Cooming Soon",
text="This option is not yet available.",
buttons=[
MDFlatButton(text="Cancel",
text_color=self.theme_cls.primary_color,
on_press=lambda x: self.dialog.dismiss())
])
self.dialog.open()
class CameraOpenCV(XCamera):
directory = "%s/DCIM/" % primary_external_storage_path()
def on_camera_ready(self):
Logger.debug("on_camera_ready %s " % self.directory)
def _app_dir(self):
return primary_external_storage_path()
def __init__(self, **kwargs):
super(CheckList, self).__init__(**kwargs)
if platform == "android":
from android.storage import primary_external_storage_path
from android.permissions import request_permissions, check_permission, Permission
sdcard = primary_external_storage_path()
dataDir = sdcard + '/plocka'
if not os.path.exists(dataDir):
request_permissions([
Permission.READ_EXTERNAL_STORAGE,
Permission.WRITE_EXTERNAL_STORAGE
])
while not check_permission(Permission.WRITE_EXTERNAL_STORAGE):
time.sleep(1)
else:
dataDir = os.environ['HOME'] + '/.config/Plocka'
os.makedirs(dataDir, exist_ok=True)
scriptDir = os.path.dirname(os.path.realpath(__file__))
global shoppingList
try:
with open(dataDir + '/Plocka.json') as fd:
shoppingList = json.load(fd)
except:
shoppingList = [{
"section":
"Section 1",
"items": [{
"item": "Item 1",
"done": False
}, {
"item": "Item 2",
"done": True
}, {
"item": "Item 3",
"done": True
}]
}, {
"section":
"Section 2",
"items": [{
"item": "Item 1",
"done": True
}, {
"item": "Item 2",
"done": False
}, {
"item": "Item 3",
"done": False
}, {
"item": "Item 4",
"done": True
}]
}, {
"section":
"Section 3",
"items": [{
"item": "Item 1",
"done": True
}, {
"item": "Item 2",
"done": True
}, {
"item": "Item 3",
"done": False
}]
}]
defaultSettings = {
'headerSize': '40sp',
'sectionSize': '20sp',
'sectionColor': [0.1, 0.2, 0.2, 1],
'sectionTextSize': '10sp',
'itemSize': '30sp',
'itemColor': [0.20, 0.25, 0.29, 1],
'doneColor': [0.24, 0.30, 0.35, 1],
'actionColor': [.2, .7, .9, 1],
'activeColor': [1, 1, 1, 1],
'inactiveColor': [1, 1, 1, 0.5],
'redColor': [1, 0, 0, 0.5],
'greenColor': [0, 1, 0, 0.5],
'backupsToKeep': 10,
'maxBackupAge': 1,
'showSections': 'maybe',
}
try:
with open(dataDir + '/settings.json') as fd:
settings = json.load(fd)
for key in defaultSettings:
if not key in settings:
settings[key] = defaultSettings[key]
except:
settings = defaultSettings
backups = sorted(glob(f'{dataDir}/Plocka-*.json'))
cutoff = (
datetime.now() -
timedelta(days=settings['maxBackupAge'])).strftime("%Y%m%d%H%M%S")
for backup in backups[:-settings['backupsToKeep']]:
if backup < f'{dataDir}/Plocka-{cutoff}.json':
print('deleting backup file ' + backup)
os.remove(backup)
def hide(widget):
if widget.height:
widget.restore = widget.height
widget.height = 0
widget.opacity = 0
widget.disabled = True
def unhide(widget):
if widget.disabled:
widget.height = widget.restore
widget.opacity = 1
widget.disabled = False
def checkSection(stack, current):
for item in stack.children[::-1]:
if item.type == 'section':
section = item
if item == current:
break
index = stack.children.index(section)
for item in stack.children[index - 1::-1]:
if item.type == 'item' and item.check.state == 'normal':
return
if item.type == 'section':
break
hide(section)
self.writeDeferred = False
def writeFile(dt):
if dt and not self.writeDeferred:
return
self.writeDeferred = False
activeList = []
for item in stack.children[::-1]:
if item.type == 'item':
entry = {
"item": item.text,
"done": item.check.state == 'down'
}
section["items"].append(entry)
elif item.type == 'section':
section = {"section": item.origText, "items": []}
activeList.append(section)
shoppingList['lists'][shoppingList['active']]['name'] = title.text
shoppingList['lists'][shoppingList['active']]['list'] = activeList
now = datetime.now().strftime("%Y%m%d%H%M%S")
if os.path.exists(f'{dataDir}/Plocka.json'):
os.rename(f'{dataDir}/Plocka.json',
f'{dataDir}/Plocka-{now}.json')
with open(f'{dataDir}/Plocka.json', 'w', encoding='utf8') as fd:
json.dump(shoppingList, fd, indent=2, ensure_ascii=False)
saveBtn.color = settings['greenColor']
def undo(instance):
global shoppingList
try:
last = sorted(glob(f'{dataDir}/Plocka-*.json'))[-1]
os.rename(last, f'{dataDir}/Plocka.json')
with open(dataDir + '/Plocka.json') as fd:
shoppingList = json.load(fd)
populate()
hideUnHide(hideBtn)
except:
pass
def toggle(instance):
if instance.check.state == 'down':
instance.background_color = settings['itemColor']
instance.color = settings['activeColor']
instance.check.state = 'normal'
else:
instance.background_color = settings['doneColor']
instance.color = settings['inactiveColor']
instance.check.state = 'down'
if not self.writeDeferred:
self.writeDeferred = True
saveBtn.color = settings['actionColor']
Clock.schedule_once(writeFile, 10)
if hideBtn.state == 'down' and instance.check.state == 'down':
hide(instance.check)
hide(instance)
checkSection(stack, instance)
def hideUnHide(instance):
if hideBtn.state != "down" and not searchInput.text:
for item in stack.children[:]:
unhide(item)
elif searchInput.text == searchInput.text.upper(
) and searchInput.text != searchInput.text.lower():
activeSection = False
for item in stack.children[::-1]:
if item.type == 'section':
if re.search(searchInput.text, item.text):
activeSection = True
else:
activeSection = False
if activeSection and (
hideBtn.state != 'down' or item.type != 'item'
and item.type != 'check' or hideBtn.state == 'down'
and item.type == 'check' and item.state != 'down'
or hideBtn.state == 'down' and item.type == 'item'
and item.check.state != 'down'):
unhide(item)
else:
hide(item)
else:
hasChildren = False
regexp = searchInput.text if searchInput.text else '.'
for item in stack.children[:]:
if item.type == 'item':
if hideBtn.state == "down" and item.check.state == 'down' or not re.search(
regexp, item.text, re.IGNORECASE):
hide(item.check)
hide(item)
else:
unhide(item.check)
unhide(item)
hasChildren = True
elif item.type == 'section':
if hasChildren and settings['showSections'] == 'always':
unhide(item)
hasChildren = False
else:
hide(item)
def crossCheck(instance):
toggle(instance.label)
def edit(instance):
entry = TextInput(
text=instance.text,
size_hint=(0.5, None),
height=settings['itemSize'],
multiline=False,
on_text_validate=lambda w: updateItem(w),
)
if instance.type == 'section':
entry.text = instance.origText
relative = ImageButton(
source='data/left.png'
if instance.type == 'item' else 'data/right.png',
color_normal=[1, 1, 1, .7],
height=settings['itemSize'],
size_hint=(0.1, None),
on_release=lambda w: updateItem(entry),
)
before = ImageButton(
source='data/up.png',
color_normal=[1, 1, 1, .7],
height=settings['itemSize'],
size_hint=(0.1, None),
on_release=lambda w: updateItem(entry),
)
replace = ImageButton(
source='data/ok.png',
color_normal=[0, .5, 0, 1],
height=settings['itemSize'],
size_hint=(0.1, None),
on_release=lambda w: updateItem(entry),
)
after = ImageButton(
source='data/down.png',
color_normal=[1, 1, 1, .7],
height=settings['itemSize'],
size_hint=(0.1, None),
on_release=lambda w: updateItem(entry),
)
delete = ImageButton(
source='data/delete.png',
color_normal=[.5, 0, 0, 1],
height=settings['itemSize'],
size_hint=(0.1, None),
on_release=lambda w: updateItem(entry),
)
entry.orig = instance
entry.relative = relative
entry.before = before
entry.replace = replace
entry.after = after
entry.delete = delete
entry.type = 'entry'
relative.type = 'relative'
before.type = 'before'
replace.type = 'replace'
after.type = 'after'
delete.type = 'delete'
hide(instance)
if instance.type == 'item':
hide(instance.check)
index = stack.children.index(instance)
stack.add_widget(delete, index)
stack.add_widget(entry, index)
stack.add_widget(relative, index)
stack.add_widget(before, index)
stack.add_widget(replace, index)
stack.add_widget(after, index)
entry.select_all()
Clock.schedule_once(lambda dt: reselect(entry), 0.5)
def reselect(entry):
# repeat select_all after half a second to avoid losing focus on release
entry.focused = True
entry.select_all()
def updateItem(entry):
todo = 'replace'
if entry.delete.state == 'down':
todo = 'delete'
elif entry.before.state == 'down':
todo = 'before'
elif entry.after.state == 'down':
todo = 'after'
elif entry.relative.state == 'down':
if entry.orig.type == 'section':
todo = 'item'
else:
todo = 'section'
orig = entry.orig
text = entry.text
stack.remove_widget(entry.relative)
stack.remove_widget(entry.before)
stack.remove_widget(entry.replace)
stack.remove_widget(entry.after)
stack.remove_widget(entry.delete)
stack.remove_widget(entry)
if todo == 'delete':
stack.remove_widget(orig)
if orig.type == 'item':
stack.remove_widget(orig.check)
else:
unhide(orig)
if orig.type == 'item':
unhide(orig.check)
if todo == 'replace':
if orig.type == 'section':
orig.origText = text
orig.text = text.upper()
else:
orig.text = text
else:
if orig.type == 'section' and todo != 'item' or todo == 'section':
label = sectionButton(text)
else:
label = itemButtonPair(text, False)
index = stack.children.index(orig)
if todo == 'before' or todo == 'section':
index += 1
if orig.type == 'item':
if todo == 'before' or todo == 'section':
index += 1
if label.type == 'item':
stack.add_widget(label.check, index)
stack.add_widget(label, index)
edit(label)
writeFile(0)
self.searchDeferred = False
def doSearch(text, undo):
if not self.searchDeferred:
self.searchDeferred = True
Clock.schedule_once(filterOut, 1)
return text
def filterOut(dt):
self.searchDeferred = False
hideUnHide(hideBtn)
def setBookmark():
now = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
os.makedirs(f'{dataDir}/bookmarks', exist_ok=True)
print(f"set bookmark '{dataDir}/bookmarks/{now}.json'")
shutil.copy(f'{dataDir}/Plocka.json',
f'{dataDir}/bookmarks/{now}.json')
bookmark = ''
def getBookmark():
popup = Popup(
title="Bookmarks",
content=BookmarkList(
dataDir=dataDir,
settings=settings,
orientation='vertical',
),
size_hint=(0.9, 0.9),
)
popup.bind(on_pre_dismiss=useBookmark)
popup.open()
def useBookmark(w):
global shoppingList
bookmark = w.content.chosen
if not bookmark:
print('no bookmark chosen')
return
writeFile(0)
shutil.copy(f'{dataDir}/bookmarks/{bookmark}.json',
f'{dataDir}/Plocka.json')
with open(f'{dataDir}/Plocka.json') as fd:
shoppingList = json.load(fd)
populate()
def selectList(w):
global shoppingList
dropdown = DropDown(
on_select=lambda instance, selected: setActive(selected),
)
index = -1
for item in shoppingList['lists']:
index += 1
if index == shoppingList['active']:
continue
btn = Button(
text=item['name'],
size_hint_y=None,
background_color=settings['sectionColor'],
height=settings['itemSize'],
)
btn.index = index
btn.bind(on_release=lambda btn: dropdown.select(btn.index))
dropdown.add_widget(btn)
about = Button(
text="About Plocka",
size_hint_y=None,
background_color=settings['sectionColor'],
height=settings['itemSize'],
)
about.bind(on_release=lambda about: dropdown.select(-1))
dropdown.add_widget(about)
dropdown.open(w)
def setActive(selected):
if selected > -1:
global shoppingList
shoppingList['active'] = selected
populate()
writeFile(0)
else:
with open(scriptDir + '/ABOUT.rst') as fd:
about = fd.read()
with open(scriptDir + '/LICENSE') as fd:
license = fd.read()
aboutText = RstDocument(text=about +
'\n\nLicense\n-------\n\n' + license, )
popup = Popup(
title="Plocka " + __version__,
content=aboutText,
)
popup.open()
def editList(w):
buttonBox = BoxLayout()
top.add_widget(buttonBox)
delete = ImageButton(
source='data/delete.png',
color_normal=[.5, 0, 0, 1],
size_hint_x=None,
width=settings['headerSize'],
on_release=lambda w: deleteList(w),
)
buttonBox.add_widget(delete)
entry = TextInput(
text=w.text,
height=settings['headerSize'],
multiline=False,
on_text_validate=lambda w: setListName(w),
)
buttonBox.add_widget(entry)
saveBtn = ImageButton(
source="data/ok.png",
color_normal=settings['greenColor'],
size_hint_x=None,
width=settings['headerSize'],
on_release=lambda x: setListName(entry),
)
buttonBox.add_widget(saveBtn)
copy = ImageButton(
source='data/copy.png',
color_normal=[1, 1, 1, .7],
size_hint_x=None,
width=settings['headerSize'],
on_release=lambda w: copyList(w),
)
buttonBox.add_widget(copy)
new = ImageButton(
source='data/new.png',
color_normal=settings['greenColor'],
size_hint_x=None,
width=settings['headerSize'],
on_release=lambda w: createList(entry),
)
buttonBox.add_widget(new)
top.remove_widget(title)
top.remove_widget(searchBtn)
entry.focused = True
def closeEditor(w):
top.add_widget(title)
top.add_widget(searchBtn)
top.remove_widget(w.parent)
def setListName(w):
title.text = w.text
closeEditor(w)
writeFile(0)
def createList(w):
global shoppingList
new = {
'name': 'New list',
'list': [{
'section': 'Section',
'items': []
}]
}
at = shoppingList['active'] + 1
shoppingList['lists'].insert(at, new)
setActive(at)
closeEditor(w)
def copyList(w):
global shoppingList
at = shoppingList['active']
new = json.loads(json.dumps(shoppingList['lists'][at]))
new['name'] += ' 2'
at += 1
shoppingList['lists'].insert(at, new)
setActive(at)
closeEditor(w)
def deleteList(w):
at = shoppingList['active']
del (shoppingList['lists'][at])
if at >= len(shoppingList['lists']):
at = at - 1
setActive(at)
closeEditor(w)
# Widgets
def sectionButton(text):
label = LongpressButton(
text=text.upper(),
font_size=settings['sectionTextSize'],
height=settings['sectionSize'],
background_color=settings['sectionColor'],
size_hint=(1, None),
on_long_press=lambda w: edit(w),
)
label.origText = text
label.type = 'section'
return label
def itemButtonPair(text, done):
label = LongpressButton(
text=text,
height=settings['itemSize'],
background_color=settings['itemColor'],
size_hint=(0.95, None),
on_short_press=lambda w: toggle(w),
on_long_press=lambda w: edit(w),
)
label.type = 'item'
check = CheckBox(
height=settings['itemSize'],
size_hint=(0.05, None),
on_release=lambda w: crossCheck(w),
)
if done:
label.background_color = settings['doneColor']
label.color = settings['inactiveColor']
check.state = 'down'
check.type = 'check'
check.label = label
label.check = check
return label
def populate():
global shoppingList
if not 'lists' in shoppingList:
shoppingList = {
'lists': [{
'name': 'Plocka',
'list': shoppingList
}]
}
if not 'active' in shoppingList:
shoppingList['active'] = 0
title.text = shoppingList['lists'][shoppingList['active']]['name']
stack.clear_widgets()
for section in shoppingList['lists'][
shoppingList['active']]['list']:
if settings['showSections'] != 'never':
sectionLabel = sectionButton(section['section'])
stack.add_widget(sectionLabel)
for item in section['items']:
label = itemButtonPair(item['item'], item['done'])
stack.add_widget(label.check)
stack.add_widget(label)
def toggleSearch(widget):
if searchInput.disabled:
top.add_widget(searchInput, 1)
searchInput.disabled = False
searchInput.focused = True
else:
searchInput.text = ''
searchInput.disabled = True
top.remove_widget(searchInput)
hideUnHide(hideBtn)
# MAIN
top = BoxLayout(
size_hint=(1, None),
height=settings['headerSize'],
)
self.add_widget(top)
title = LongpressButton(
text='Unknown',
background_color=settings['sectionColor'],
on_short_press=selectList,
on_long_press=editList,
)
top.add_widget(title)
searchBtn = ImageButton(
source='data/search.png',
width=settings['headerSize'],
color_normal=[1, 1, 1, .6],
on_release=toggleSearch,
size_hint_x=None,
)
top.add_widget(searchBtn)
searchInput = TextInput(
disabled=True,
multiline=False,
input_filter=doSearch,
on_text_validate=lambda w: hideUnHide(hideBtn),
)
scrollBox = ScrollView(
size_hint=(1, .9),
do_scroll_x=False,
)
self.add_widget(scrollBox)
stack = StackLayout(size_hint=(1, None))
stack.bind(minimum_height=stack.setter('height'))
scrollBox.add_widget(stack)
populate()
buttons = BoxLayout(
size_hint=(1, None),
height=settings['headerSize'],
)
self.add_widget(buttons)
saveBtn = ImageButton(
source="data/ok.png",
color_normal=settings['greenColor'],
on_release=lambda x: writeFile(0),
)
buttons.add_widget(saveBtn)
hideBtn = ToggleImageButton(
image_down="data/show.png",
image_normal="data/hide.png",
color_down=[1, 1, 1, .9],
color_normal=[1, 1, 1, .6],
on_release=hideUnHide,
)
buttons.add_widget(hideBtn)
undoBtn = ImageButton(
source='data/undo.png',
color_normal=settings['redColor'],
on_release=undo,
)
buttons.add_widget(undoBtn)
bookmarkBtn = LongpressImageButton(
source='data/bookmark.png',
color_normal=settings['greenColor'],
on_short_press=lambda w: setBookmark(),
on_long_press=lambda w: getBookmark(),
)
buttons.add_widget(bookmarkBtn)
def picture_taken(self, obj, filename):
Logger.debug("picture_taken %s => %s" % (obj, filename))
App.get_running_app().manager.switch_to("Editor")
App.get_running_app().manager.current_screen.source = os.path.join("%s/DCIM/" % primary_external_storage_path(), filename)
def build(self): writer() # <---- calling testwrite() here ffolder = os.path.join(primary_external_storage_path(),'KT') fname = os.path.join(ffolder,'testfile.txt') text = open(fname,'r').read() #reading the written txt return MDLabel(text = text, halign="center") # displaying
def build(self):
Loop = 0
LabelArr = [0 for x in range(30)]
# Logger.critical("DEADBEEF10 = {}")
# Logger.debug (" *** DEADBEEF *** ")
if platform == 'android':
from android.storage import primary_external_storage_path
Logger.critical("android")
# Get path to SD card Android
theFtSize = '14sp'
ScreenHeight = 1400
AndPath = primary_external_storage_path()
Logger.critical(AndPath)
# FileLocation = os.path.join(AndPath, "/AndMyInfoFile.txt")
FileLocation = AndPath + "/Elias/AndMyInfoFile.txt"
Logger.critical(FileLocation)
if platform == 'linux':
Logger.critical("linux")
FileLocation = "/home/Logs/MyInfoFile.txt"
theFtSize = '24sp'
ScreenHeight = 750
# Load the values from the same date
# in case the app closed.
def ReadFile(FileName):
now = str(datetime.datetime.now().strftime("%Y-%m-%d, "))
try:
MyFile = open(FileName, "r")
except:
return
for line in MyFile:
if now in line:
theIndex = 0
for Item in ButtonInfo:
if (Item[0] in line):
CurCount[theIndex] += 1
# print("Found ",Item, CurCount[theIndex])
theIndex += 1
# print(CurCount)
MyFile.close()
# CurCount
# Update the counts
ReadFile(FileLocation)
# Open the file for writing and
# insert the date.
now = datetime.datetime.now()
MyFile = open(FileLocation, "a+")
MyFile.write(now.strftime("%Y-%m-%d, "))
MyFile.write(now.strftime("%H:%M:%S, "))
MyFile.write("App Start")
MyFile.write("\n\r")
# Create the grid
# 2 number column and 2 text.
button_grid = GridLayout(cols=4,
size_hint=(None, None),
col_default_width=100,
height=ScreenHeight)
# col_default_width=100,height=750)
button_grid.bind(minimum_height=button_grid.setter('height'))
# Insert the values into the grid
Loop = 0
for theButton in ButtonInfo:
# print(theButton[0], Loop)
LabelArr[Loop] = Label(text=str(CurCount[Loop]),
font_size=theFtSize,
size_hint_x=None,
width=50)
button_grid.add_widget(LabelArr[Loop])
ButtonText = theButton[0]
button_grid.add_widget(
Button(text=ButtonText,
background_color=theButton[1],
font_size=theFtSize,
min_state_time=1,
size_hint_x=None,
width=245))
Loop += 1
# Not used
def on_checkbox_active(checkbox, value):
if value:
print('The checkbox', checkbox, 'is active')
else:
print('The checkbox', checkbox, 'is inactive')
# Given the text up the count
def IncrementValue(ButtonText):
global Loop
Loop = 0
for theButton in ButtonInfo:
if (theButton[0] == ButtonText):
CurCount[Loop] = CurCount[Loop] + 1
LabelArr[Loop].text = str(CurCount[Loop])
Loop += 1
# Write the value and date to the file.
def print_button_text(instance):
# print("Button Pressed", instance)
# print("Logger.debug", instance)
now = datetime.datetime.now()
MyFile.write(now.strftime("%Y-%m-%d, "))
MyFile.write(now.strftime("%H:%M:%S, "))
MyFile.write(instance.text)
MyFile.write("\n\r")
MyFile.flush()
IncrementValue(instance.text)
for button in button_grid.children[1:]:
button.bind(on_press=print_button_text)
def print_slider_value(instance, value):
print("Logger.debug", value)
# Not used
def resize_label_text(label, new_height):
label.font_size = 0.5 * label.height
root_widget = ScrollView(size_hint=(1, 1),
size=(Window.width, Window.height))
# root_widget.size = (480, 320)
root_widget.add_widget(button_grid)
return root_widget
def android_ext_dir():
from android.storage import primary_external_storage_path
return primary_external_storage_path()
from kivymd.uix.spinner import MDSpinner
from kivymd.uix.button import MDFlatButton
from kivymd.uix.list import OneLineListItem
from kivy.clock import Clock
from functools import partial
from threading import Thread
import os
from apiclient.discovery import build
from apiclient.errors import HttpError
from oauth2client.tools import argparser
from kivy.utils import platform
if platform=='android':
from android.permissions import request_permissions, Permission, check_permission
from android.storage import primary_external_storage_path
primary_ext_storage = primary_external_storage_path() + "/Download"
else:
primary_ext_storage = os.getcwd() + "/Download"
DEVELOPER_KEY = ""
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"
def youtube_search(q, max_results=1,order="relevance", token=None, location=None, location_radius=None):
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
developerKey=DEVELOPER_KEY)
search_response = youtube.search().list(
q=q,
type="video",
pageToken=token,
