core_FRONTEND
"""
Copyright (C) 2020 Ryan McKenna All Rights Reserved
core_FRONTEND holds human-to-machine interaction code in a user-defined interface
This interface is meant to showcase what can be imagined with EntityScript(TM)
You can branch any terminal emulator, system program, or code extension into a text
or other text-based emulation device here. The production version of this system
has many improvements, but this is the showcase build.
This script is a collection of each of these pieces. Beware, it's by far the most complex
script in the stack and has had to be rearranged many times to get ordering and instance ques
correct.
If you add to it, make sure you follow preexisting conventions and start SMALL.
SMALL means with buttons or fields in position first, then add functionality gradually.
Alerts and Logging make anything here auditable.
The operations displayed here can also be put inside digital-thread container to increase
the safety of the envionrment even more.
Certain dynamic content has been omitted from the document.
This script holds the base philosophy for:
1.) Virtually-contained meta-organizer system (VMS)
2.) Cognitive Operations Resource Enclave (C.ORE)
3.) Stateful computer system: Maintained by software and hardware devices,
allowing for 3rd party experiences that derived from
machine-to-human generated interface organized commands or components and then outputing
those experices in audio, text, visual, and other sensory outputs.
There are three starting sections to this file.
1.) Standard: Output
- Allows for a computer input/output integration
2.) Standard: Visual Build
- Allows for operator-interface interactions and layering
3.) Standard: Extensions
- Allows for adding and removing C.ORE interaction packages
4.) Standard: Document Viewer
- Allows for operator-to-machine interaction in audio, visual, and other sensory types
"""
## Imports: Standard-> Built-in imports (Base package)
# -> No direct Imports Listed
## Imports: Standard-> Built-in imports for Graphical Interface (From package)
from glob import glob
from hashlib import md5
from io import BytesIO
from os import chdir, getcwd
from os.path import basename, dirname, getsize
from shutil import rmtree
from tempfile import mkdtemp
from time import sleep
## Built-in imports: altered name spaces
# ITL: Interaction Translation Layer
import tkinter as ITL
from tkinter import (
_tkinter, ttk,
scrolledtext, Menu, messagebox as MB,
Spinbox, Text, Listbox, Button, PhotoImage
)
## Imports: Community packages: Addons
from PIL import (
Image, ImageTk, GifImagePlugin, ImageSequence
)
## Imports: General Data
from CORE import (
MANIPULATE_OFFICIAL_ENTRY,
)
## Imports: Custom
from core_settings import (
# System Ques
GLOBAL_MEMBER,
PUBLIC_MEMBER,
system_member
)
from core_middlelayer import (
# Alerts
STANDARDERROR, STANDARDWARNING, QUITALERT,
# Basics
FE_COLORS, FE_copyright, FE_CORETITLE, FE_DIRPICTURES, FE_ICON,
SLUG_ICON,
w_scrolled, h_scrolled, x_logic_resize, y_logic_resize,
# Cognitive ORE
# Slug: _CONTROL_FOLDER_*
CONTROL_FOLDER_AUDIO, CONTROL_FOLDER_MEMORY_VAULT,
CONTROL_FOLDER_ORE, CONTROL_FOLDER_VISUAL_VAULT,
CONTROL_FOLDER_VIDEOS,
# Slug: FOLDER_*
FOLDER_AUDIO_CONTROL_KEY, FOLDER_ORE_CONTROL_KEY,
FOLDER_MEMORY_VAULT_KEY, FOLDER_VIDEOS_CONTROL_KEY,
FOLDER_VISUAL_CONTROL_KEY, FOLDER_VISUAL_CONTROL_KEY_ALT,
FOLDER_VISUAL_CONTROL_KEY_SPECIAL,
# Contact
CONTACT_BUSINESS_LEDGER, CONTACT_INDEX_LEDGER, DIRCONTACT,
# Data
DIRDATA,
# Keys
KEY, KEY_LOCATION,
# Information
DOCUMENTS_LOCATION, README, SUBCOPYRIGHT,
# Ledger Slugs
SLUG_DOCUMENT_LEDGER,
SLUG_ENTITY_LEDGER, ENTITY_LOCATION, SLUG_ENTITY_MANIFEST,
SLUG_FIGMENT_FULL,
SLUG_ORE_LEDGER,
SLUG_LOCKERLINKS_STORAGE_DS,
# lockerlinks.ini
SLUG_LL_COMPACT,
KEY_LL, KEY_LL_PLAIN, LL_ACTIVE_RING_LINK, LLES,
KEY_LL1, KEY_LL2, KEY_LL3, KEY_LL4, KEY_LL5,
KEY_LL6, KEY_LL7, KEY_LL8, KEY_LL9, KEY_LL10,
KEY_LLB, KEY_LLB_PLAIN, LLBES,
KEY_PK, KEY_PK_PLAIN,
KEY_CATEGORY_SET_CHARACTER, KEY_CATEGORY_SET_RANK,
KEY_FEATURES, KEY_DIRECTORY, KEY_TITLE,
KEY_TOKEN_ID, KEY_QUALITY,
SLUG_LLB_COMPACT,
# Network
SLUG_DEFAULT_NETWORK,
# Operator
DEFAULT_OPERATOR_PHOTO, gatekeeper_photo, SLUG_OPERATOR,
# Packages
PACKAGES,
# ring.ini: Extras
ENTITY_HUMAN_PERSON_DATASHEET, XLX, CONTACT_SLUG_LINKER,
ext_ds, ext_es, RINGVISUAL, PORTCONNECT_TO,
SLUG_HOST_PERSONAL, RING_HOST as LOCALHOST,
default_Welcome, encoding_connect_in,
ACTIVEES, LOGES,
# Utils
DASH_UTIL,
)
# Establish the Gatekeeper: gatekeeper.py
from core_gatekeeper import ALIEN_VAULT_CONSTRUCT
# Entity Login: Accepted-> build the standard 'SERVERALPHA' and Interaction Binds
# Events and Alerts Positional Classes
from core_interface import (
Access, Identity, Ring,
SERVERALPHA,
SystemTime,
XYInteractEvent, XYInteractEventBindings
)
##Logging: Standardized Types
from core_alerts import (
ACTION_AUDITED, ACTION_ENTITYSCRIPT_RECORDER,
ACTION_KING_SLUG_RECORDER,
ACTION_REGULAR, ACTION_SEARCH_RECORDER,
ALERT_LOGGING_FAILURE, ALERT_LOGGING_INFO,
ALERT_LOGGING_WARNING,
LOADER_DS
)
## Communications: Stack
# Import _add, _operations, _url
from core_add import (
default_add,
server_add
)
from core_operations import (
GET_global_CONSTRUCTEDCOREES_LOG,
GET_local_COREES_LOG,
PARSE_ENTITY,
PathRetrieverBrowsemeh
)
from core_url import (
GO,
Move,
Slug_Bucket,
url_slug
)
## Add, Delete, or Edit system settings
# Language
from core_language import (
LANG_PROPAGATE as LP,
)
## OpenPackager
# Base Setup Classes: Meant to be where you customize I/O from.
from OPENPACKAGER.corehost.StandardOutput01 import (
VisualOutputStarting,
)
class_instance_core_gather = VisualOutputStarting.establish()
# Also, add Standard: Visual Build System (SVBS)
#import OPENPACKAGER.corehost.StandardVisualBuild02 as GENERATE_VISUAL
#GENERATE_VISUAL.ENTITY_CONSTRUCT()
# Built-in: OpenPackager: BrowseMeh
import OPENPACKAGER.corehost.BROWSEMEH.op_BROWSEMEH as BM
# Built-in: OpenPackager: EventLolli
import OPENPACKAGER.corehost.EVENTLOLLI.op_EVENTLOLLI as EL
# Built-in: OpenPackager: RemindMe
import OPENPACKAGER.corehost.REMINDME.op_REMINDME as RM
# Window-mode: OpenPackager: Interface
from OPENPACKAGER.corehost.StandardExtension03 import (
ENTITY_CONSTRUCT_SUB_OPENPACKAGER,
)
# Window-mode: OpenPackager: SDV (Standard Document Viewer)
from OPENPACKAGER.corehost.StandardDocumentViewer04 import (
ENTITY_CONSTRUCT_SUB_SDV,
)
# Main Library FRONTEND
class ENTITY_CONSTRUCT():
def __init__(self):
"""
ENTITY_CONSTRUCT() will Set all baseline functions and objects
required to operate the Entity
"""
# Interface Middle Layer Imports
self.FRONTEND_INTERFACE = ITL.Tk()
# Screen Dynamics
SCREEN_W = self.FRONTEND_INTERFACE.winfo_screenwidth()
SCREEN_H = self.FRONTEND_INTERFACE.winfo_screenheight()
fpixels = self.FRONTEND_INTERFACE.winfo_fpixels('1i')
print(
str(fpixels)+\
' DPI detected. '+\
'Also, SCREEN_W: '+str(SCREEN_W)+' and SCREEN_H: '+str(SCREEN_H)
)
#if SCREEN_H >=2160:
# code here
if SCREEN_W >= 3840 and fpixels >= 96:
self.FRONTEND_INTERFACE.call('tk', 'scaling', 1.00)
print("Ran init case")
else:
self.FRONTEND_INTERFACE.call('tk', 'scaling', 1.42)
print("Ran secondary case")
self.FRONTEND_INTERFACE.protocol(
"WM_DELETE_WINDOW",
SERVERALPHA.DECLUTTER_REQUESTER()
)
self.FRONTEND_INTERFACE.minsize(width=50, height=50)
self.FRONTEND_INTERFACE.title(FE_CORETITLE)
self.FRONTEND_INTERFACE.tk.call(
'wm', 'iconphoto',
self.FRONTEND_INTERFACE._w,
PhotoImage(file=SLUG_ICON+FE_ICON)
)
self.FRONTEND_INTERFACE.resizable(x_logic_resize, y_logic_resize)
## Define the state: First startup the state is 0
# Upon a completed startup the state becomes 1
self.STATE = 1
## Logic Overview: Presets
self.FE_COLORS = ["Black", "Grey", "Red"]
## Start the common functions
self.create_entity_menu()
self.create_entity_module()
## Copyright information
copyright = ttk.Label(self.FRONTEND_INTERFACE, text=FE_copyright)
copyright.pack()
def create_entity_menu(self):
"""
ENTITY MENU
"""
MENUMAIN = Menu(self.FRONTEND_INTERFACE)
self.FRONTEND_INTERFACE.config(menu=MENUMAIN)
NavigatorRootMenu = Menu(MENUMAIN, tearoff=0)
NavigatorRootMenu.add_command(label="New")
NavigatorRootMenu.add_separator()
NavigatorRootMenu.add_command(label="EXIT", command=self._QuitCORE)
MENUMAIN.add_cascade(label="File", menu=NavigatorRootMenu)
NavigatorHelpMenu = Menu(MENUMAIN, tearoff=0)
NavigatorHelpMenu.add_command(label="About")
NavigatorHelpMenu.add_separator()
NavigatorHelpMenu.add_command(label="Copyright",
command=self.ALERT_MESSAGE_INFO_COPYRIGHT
)
MENUMAIN.add_cascade(label="Help", menu=NavigatorHelpMenu)
def _QuitCORE(self):
"""
Quit and Exit button logic
"""
response = MB.askyesnocancel('Confirm Quit', QUITALERT)
if response == True:
self.FRONTEND_INTERFACE.quit()
self.FRONTEND_INTERFACE.destroy()
SERVERALPHA.DECLUTTER_REQUESTER()
exit()
else:
pass
def ALERT_MESSAGE_INFO_COPYRIGHT(self):
"""
Standard Copyright Info output
"""
MB.showinfo('Copyright Information', LP.COPYRIGHT+'\n'+SUBCOPYRIGHT)
def ALERT_MESSAGE_ERROR_STANDARD(self):
"""
Standard Error Info output
"""
MB.showerror('Error Detected!', STANDARDERROR)
def ALERT_MESSAGE_WARNING_STANDARD(self):
"""
Standard Warning Info Output
"""
MB.showinfo('Warning!', STANDARDWARNING)
def create_entity_module(self):
'''
Interior Windows
'''
INTERFACE_CONTROLLER = ttk.Notebook(self.FRONTEND_INTERFACE)
style = ttk.Style()
style.theme_settings("default",
{"TNotebook.Tab": {"configure": {"padding": [30, 30]}}}
)
# Add a rowheight default style
ttk.Style().configure('Treeview',
rowheight=44
)
## OpenPackager: BROWSEMEH
tab_im_browsemeh = ITL.PhotoImage(
file=BM.BROWSEMEH_GIF_FOLDER+BM.BROWSEMEH_GIF_NAME
)
BROWSEMEH = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(BROWSEMEH,
text='BROWSEMEH\u2122', compound= ITL.LEFT, image=tab_im_browsemeh
)
# SETUP_RELATED: RemindMe (Keeps time and events)
REMINDME = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(REMINDME, text='REMINDME\u2122')
## CORE-> DOCS HERE
#from DOCUMENTATION.doctree import ENTITY_CONSTRUCT_SUB
#ENTITY_CONSTRUCT_SUB()
#INTERFACE_CONTROLLER.add(ENTITY_CONSTRUCT_SUB, text='C.ORE \u2122')
## AIREP-> Active
# Base
ENTITY_OVERVIEW = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(ENTITY_OVERVIEW, text='OVERVIEW')
# SETUP_RELATED: ACCESS (Acess and Sort Entities and Keys)
ENTITY_ACCESS = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(ENTITY_ACCESS, text='ACCESS')
# SETUP_RELATED: IDENTITY (for a single Operator by default. Multi-Op IS possible.)
ENTITY_IDENTITY = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(ENTITY_IDENTITY, text='IDENTITY')
# SETUP_RELATED: RING
ENTITY_RING = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(ENTITY_RING, text='RING')
# Enhancements: Active Lookup .ds/.entity
ENTITY_ACTIVE = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(ENTITY_ACTIVE, text='ACTIVE')
# OpenPackager: EventLolli (Optional ad/rewards/network delivery framework)
EVENTLOLLI = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(EVENTLOLLI, text='EVENTLOLLI\u2122')
## OpenPackager: Expander (Each of these will make a new window
# to disable the window uncomment the constructor below
# OP_SDV = ENTITY_CONSTRUCT_SUB_SDV()
# OP_PACKAGES = ENTITY_CONSTRUCT_SUB_OPENPACKAGER()
# This frame is setup to also create UI containers for the above windows
EXPANDER = ttk.Frame(INTERFACE_CONTROLLER)
INTERFACE_CONTROLLER.add(EXPANDER, text='+')
def RelaunchLogic():
self.FRONTEND_INTERFACE.destroy()
START_INSTANCE = ENTITY_CONSTRUCT()
START_INSTANCE.FRONTEND_INTERFACE.mainloop()
refresh_button = ttk.Button(EXPANDER,
text="Refresh C.ORE \u2122",
command=RelaunchLogic
)
refresh_button.place(x=3200, y=1600)
## ENTITY_SELECTOR_INT: 1-N
ENTITY_SELECTOR_INT = ITL.IntVar()
ENTITY_SELECTOR_INT_TWO = ITL.IntVar()
ENTITY_SELECTOR_INT_THREE = ITL.IntVar()
## Frames: Active
# feature: Progress Bar
PROGRESS_BOX = ITL.Frame(ENTITY_ACTIVE,
bg='White', width=3400, height=144)
PROGRESS_BOX.place(x=12, y=44)
# Show progress unpacking, packing, or downloading a package
ENTITY_PROGRESS = ITL.Frame(PROGRESS_BOX,
width=3400, height=89)
ENTITY_PROGRESS.place(x=0, y=0)
def run_progress():
progress_bar["maximum"] = 100
for i in range(100):
sleep(0.05)
progress_bar["value"] = i
progress_bar.update()
progress_bar["value"] = 0
def run_progress_stop():
progress_bar.stop()
ENTITY_ACTIVE_INPUT = ITL.StringVar()
ENTITY_ACTIVE_ENTERED = ttk.Entry(ENTITY_ACTIVE,
width=64,
textvariable=ENTITY_ACTIVE_INPUT,
font=('Courier', 21, 'bold')
)
ENTITY_ACTIVE_ENTERED.place(x=12, y=132)
# Establish the cursor
ENTITY_ACTIVE_ENTERED.focus()
ENTITY_OVERVIEW_INPUT = ITL.StringVar()
ENTITY_OVERVIEW_ENTERED = ttk.Entry(ENTITY_OVERVIEW,
width=15,
textvariable=ENTITY_OVERVIEW_INPUT,
font=('Courier', 21, 'bold')
)
ENTITY_OVERVIEW_ENTERED.place(x=2812, y=12)
# Establish the cursor
ENTITY_OVERVIEW_ENTERED.focus()
# There can only be one item in the king bucket. Only overwriting.
KING_BUCKET_ENTITYSCRIPT_QUALIFIERS = []
# There can only be one item in the queen bucket. Only overwriting.
QUEEN_BUCKET_ENTITYSCRIPT_OVERVIEW_QUALIFIERS = []
# The TRUE_SEARCH_LIST
TRUE_SEARCH_LIST = []
PARSED_TRUE_SEARCH_LIST = []
# The LOADED_LIST
LOADED_LIST = []
PARSED_LIST = []
# Main set of buckets for the ES prefix
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW = []
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED = []
# Second set of buckets for the ES prefix
bucket_ENTITYSCRIPT_QUALIFIERS = []
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED = []
# Use this to allow switching between current and last buckets
LAST_KING_SLUG = []
LAST_QUEEN_SLUG = []
class filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL:
def pull_all_qualifiers(a):
print("LOOKUP STARTED WITH: "+a)
if a == '':
print("Nothing was done because no input was received.")
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.clear()
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.clear()
else:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.append(a)
# ENTITY_OVERVIEW_ENTERED.delete(0, ITL.END)
z = ENTITY_OVERVIEW_ENTERED.get()
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
# find_path for QUALIFIER_LOOKUP_SEED and open
with open(DIRDATA+RINGVISUAL, 'r') as f:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"SIMPLE: PARSE - VISUAL, MAIN BRANCH FILE: "+\
QUEEN_BUCKET_ENTITYSCRIPT_OVERVIEW_QUALIFIERS[0]+"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
for row in f:
print(row)
if a in row:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(row+"\n")
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
print(a)
else:
pass
#*******************************************************************#
# START: ACTION - #
# [ENTITYSCRIPT_RECORDER : #
# filter_QUALIFIERS_RING_VISUAL.pull_all_qualifiers: #
# record ENTITY SCRIPT RING (VISUAL) - ESVsearch] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [: "\
"filter_QUALIFIERS_RING_VISUAL.pull_all_qualifiers: " \
"record ENTITY SCRIPT VISUAL - ESV search] "+\
"----------"
)
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__LOGGER = \
"[ENTITYSCRIPT_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__LOGGER: "
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__helper = \
"record ENTITY SCRIPT RING (VISUAL) - ESV search] "
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__values = \
"[ESV search was ran with: - ESV: "+a+"] "
print(filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__helper+\
ACTION_ENTITYSCRIPT_RECORDER(
variable=filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__helper+\
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [ENTITYSCRIPT_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers__LOGGER] ----------"
)
#*******************************************************************#
# STOP: ACTION - #
# [ENTITYSCRIPT_RECORDER: #
# filter_QUALIFIERS_RING_VISUAL.pull_all_qualifiers: #
# record ENTITY SCRIPT RING (VISUAL) - ESV search] ----------" #
#*******************************************************************#
for i in bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED:
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT,
i
)
# ENTITY_SCROLLER_OVERVIEW_IN.configure()
z = str(bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED[:])
print("RAN WITH SEARCH SLUG: "+z)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.clear()
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.clear()
class filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW:
def pull_all_qualifiers(a):
print("LOOKUP STARTED WITH: "+a)
if a == '':
print("Nothing was done because no input was received.")
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.clear()
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.clear()
else:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.append(a)
# ENTITY_OVERVIEW_ENTERED.delete(0, ITL.END)
z = ENTITY_OVERVIEW_ENTERED.get()
# find_path for QUALIFIER_LOOKUP_SEED and open
with open(DIRDATA+SLUG_ORE_LEDGER, 'r') as f:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"SIMPLE: PARSE - ORE, MAIN BRANCH FILE: "+\
QUEEN_BUCKET_ENTITYSCRIPT_OVERVIEW_QUALIFIERS[0]+"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
for row in f:
print(row)
if a in row:
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(row+"\n")
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.append(
"-" * 79 +"\n"
)
print(a)
else:
pass
#*******************************************************************#
# START: ACTION - #
# [ENTITYSCRIPT_RECORDER : #
# filter_QUALIFIERS_ORE_OVERVIEW.pull_all_qualifiers: #
# record ENTITY SCRIPT ORE - ESO search] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [: "\
"filter_QUALIFIERS_ORE.pull_all_qualifiers: " \
"record ENTITY SCRIPT ORE - ESO search] "+\
"----------"
)
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__LOGGER = \
"[ENTITYSCRIPT_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__LOGGER: "
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__helper = \
"record ENTITY SCRIPT ORE - ESO search] "
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__values = \
"[ESO search was ran with: - ESO: "+a+"] "
print(filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__helper+\
ACTION_ENTITYSCRIPT_RECORDER(
variable=filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__helper+\
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [ENTITYSCRIPT_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers__LOGGER] ----------"
)
#*******************************************************************#
# STOP: ACTION - #
# [ENTITYSCRIPT_RECORDER: #
# filter_QUALIFIERS_ORE.pull_all_qualifiers: #
# record ENTITY SCRIPT ORE - ESO search] ----------" #
#*******************************************************************#
for i in bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED:
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT,
i
)
# ENTITY_SCROLLER_OVERVIEW_IN.configure()
z = str(bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED[:])
print("RAN WITH SEARCH SLUG: "+z)
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW_LOCATED.clear()
bucket_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.clear()
f.close()
class filter_ENTITYSCRIPT_QUALIFIERS:
def pull_all_qualifiers(a):
print("LOOKUP STARTED WITH: "+a)
if a == '':
print("Nothing was done because no input was received.")
bucket_ENTITYSCRIPT_QUALIFIERS.clear()
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.clear()
else:
bucket_ENTITYSCRIPT_QUALIFIERS.append(a)
ENTITY_SCROLLER_EMULATOR.delete("1.0", ITL.END)
# find_path for QUALIFIER_LOOKUP_SEED and open
with open(DIRDATA+ACTIVEES, 'r') as f:
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.append(
"-" * 79 +"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.append(
"SIMPLE: PARSE - DATASCRIPT FILE: "+\
KING_BUCKET_ENTITYSCRIPT_QUALIFIERS[0]+"\n"
)
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.append(
"-" * 79 +"\n"
)
for row in f:
print(row)
if a in row:
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.append(row+"\n")
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.append(
"-" * 79 +"\n"
)
print(a)
else:
pass
#*******************************************************************#
# START: ACTION - #
# [ENTITYSCRIPT_RECORDER : #
# filter_QUALIFIERS.pull_all_qualifiers: #
# record ENTITY SCRIPT - ES search] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [: "\
"filter_QUALIFIERS.pull_all_qualifiers: " \
"record ENTITY SCRIPT - ES search] "+\
"----------"
)
filter_QUALIFIERS.pull_all_qualifiers__LOGGER = \
"[ENTITYSCRIPT_RECORDER: "\
"filter_QUALIFIERS.pull_all_qualifiers__LOGGER: "
filter_QUALIFIERS.pull_all_qualifiers__helper = \
"record ENTITY SCRIPT - ES search] "
filter_QUALIFIERS.pull_all_qualifiers__values = \
"[ES search was ran with: - ES: "+a+"] "
print(filter_QUALIFIERS.pull_all_qualifiers__LOGGER+\
filter_QUALIFIERS.pull_all_qualifiers__helper+\
ACTION_ENTITYSCRIPT_RECORDER(
variable=filter_QUALIFIERS.pull_all_qualifiers__LOGGER+\
filter_QUALIFIERS.pull_all_qualifiers__helper+\
filter_QUALIFIERS.pull_all_qualifiers__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [ENTITYSCRIPT_RECORDER: "\
"filter_QUALIFIERS.pull_all_qualifiers__LOGGER] ----------"
)
#****************************************************************** #
# STOP: ACTION - #
# [ENTITYSCRIPT_RECORDER: #
# filter_QUALIFIERS.pull_all_qualifiers: #
# record ENTITY SCRIPT - ES search] ----------" #
#******************************************************************#
for i in bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED:
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
i
)
ENTITY_SCROLLER_OVERVIEW_IN.configure()
z = str(bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED[:])
print("RAN WITH SEARCH SLUG: "+z)
bucket_ENTITYSCRIPT_QUALIFIERS_LOCATED.clear()
bucket_ENTITYSCRIPT_QUALIFIERS.clear()
f.close()
KING_BUCKET_ENTITYSCRIPT_QUALIFIERS.append('Empty King Bucket: ES')
QUEEN_BUCKET_ENTITYSCRIPT_OVERVIEW_QUALIFIERS.append('Empty Queen Bucket: ES')
LABEL_ACTIVE_ENTITY_CURRENT_SLUG_LABEL = ttk.Label(ENTITY_ACTIVE,
text="Parse a .ds, .entity, or ES extention"
)
LABEL_ACTIVE_ENTITY_CURRENT_SLUG_LABEL.place(x=14, y=1620)
LABEL_ACTIVE_ENTITY_LAST_SLUG_LABEL = ttk.Label(ENTITY_ACTIVE,
text=""
)
LABEL_ACTIVE_ENTITY_LAST_SLUG_LABEL.place(x=514, y=1620)
def PULL_FILTER_ENTITYSCRIPT_QUALIFIERS():
a = ENTITY_ACTIVE_ENTERED.get()
# Remove the ES with a slice
THE_GREAT_DECIDER = a[2:]
filter_ENTITYSCRIPT_QUALIFIERS.pull_all_qualifiers(a=THE_GREAT_DECIDER)
# ORE is the self-contained overview
def PULL_FILTER_ENTITYSCRIPT_QUALIFIERS_OVERVIEW():
a = ENTITY_OVERVIEW_ENTERED.get()
# Remove the ESO with a slice
THE_GREAT_DECIDER = a[3:]
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.pull_all_qualifiers(
a=THE_GREAT_DECIDER
)
# ORE is the self-contained overview
def PULL_FILTER_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL():
a = ENTITY_OVERVIEW_ENTERED.get()
# Remove the ESO with a slice
THE_GREAT_DECIDER = a[3:]
filter_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL.pull_all_qualifiers(
a=THE_GREAT_DECIDER
)
QUEEN_BUCKET_ENTITYSCRIPT_QUALIFIERS = []
def LOAD_IT_OVERVIEW():
THE_GREAT_DECIDER = ENTITY_OVERVIEW_ENTERED.get()
# Here, the key-lookup is 'ESO'. All entity script is proceeded by the "True Key'
# So ES is the key-lookup prefix, and ESO is the key-lookup with O being the "True Key"
if THE_GREAT_DECIDER.startswith('ESO'):
# This will hold the stateful title so you can continue to do searches
# QUALIFIER_LOOKUP_SEED = KING_BUCKET_ENTITYSCRIPT_QUALIFIERS[0]
PULL_FILTER_ENTITYSCRIPT_QUALIFIERS_OVERVIEW()
elif THE_GREAT_DECIDER.startswith('ESV'):
PULL_FILTER_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL()
else:
THE_GREAT_DECIDER = THE_GREAT_DECIDER[3:]
TRUE_SEARCH_LIST.append(PARSE_ENTITY(
ENTITY_OVERVIEW_ENTERED.get()
))
QUEEN_BUCKET_ENTITYSCRIPT_QUALIFIERS.clear()
QUEEN_BUCKET_ENTITYSCRIPT_QUALIFIERS.append(THE_GREAT_DECIDER)
## PULL_FILTER_ENTITYSCRIPT_QUALIFIERS_RING_VISUAL()
## Now working on KING_BUCKET_ENTITYSCRIPT_QUALIFIERS[0]
## LABEL_OVERVIEW_ENTITY_CURRENT_SLUG_LABEL.configure(text=THE_GREAT_DECIDER)
try:
if LAST_QUEEN_SLUG[0] == None:
#*******************************************************************#
# START: ACTION - #
# [KING_SLUG_RECORDER : #
# filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT: check KING SLUG] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [QUEEN_SLUG_RECORDER : "\
"filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT: check QUEEN SLUG] "+\
"----------"
)
LAST_QUEEN_SLUG.append(THE_GREAT_DECIDER)
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__LOGGER = \
"[QUEEN_SLUG_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__LOGGER: "
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__helper = \
"check QUEEN SLUG] "
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__values = \
"[DS SLUG LOADED: memory - "+THE_GREAT_DECIDER+"] "
print(filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__helper+\
ACTION_QUEEN_SLUG_RECORDER(
variable=filter_ENTITYSCRIPT_QUALIFIERS_OVERIVEW.LOAD_IT_OVERVIEW__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT_OVERVIEW__helper+\
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT_OVERVIEW__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [QUEEN_SLUG_RECORDER : "\
"filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW__LOGGER] ----------"
)
#*******************************************************************#
# STOP: ACTION - #
# [QUEEN_SLUG_RECORDER: #
# filter_ENTITYSCRIPT_QUALIFIERS_OVERVIEW.LOAD_IT_OVERVIEW: #
# check QUEEN SLUG] ----------" #
#*******************************************************************#
LAST_QUEEN_SLUG.append(THE_GREAT_DECIDER)
elif LAST_QUEEN_SLUG[0] == THE_GREAT_DECIDER:
pass
else:
z = LAST_QUEEN_SLUG[0]
LAST_QUEEN_SLUG.clear()
LAST_QUEEN_SLUG.append(THE_GREAT_DECIDER)
LAST_QUEEN_SLUG.append(z)
# The old slug now resides in THE_GREAT_DECIDER[1]
# and can be accessed again
#LABEL_OVERVIEW_ENTITY_LAST_SLUG_LABEL.configure(text=LAST_KING_SLUG[1])
except:
IndexError
LAST_QUEEN_SLUG.append(THE_GREAT_DECIDER)
def PARSE_IT_OVERVIEW():
# run_progress_start()
with open(DIRDATA+SLUG_ORE_LEDGER, 'r') as f:
for row in f:
PARSED_TRUE_SEARCH_LIST.append(row)
f.close()
def GET_OVERVIEW():
# print("Overview gotten")
run_progress()
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
print("Active: Package")
LOAD_IT_OVERVIEW()
PARSE_IT_OVERVIEW()
try:
X = TRUE_SEARCH_LIST[0]
Y = PARSED_TRUE_SEARCH_LIST[:]
TRUE_SEARCH_LIST.clear()
PARSED_TRUE_SEARCH_LIST.clear()
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, Y)
# LOGGER: Special
GET_ACTIVE__LOGGER = \
"[GET_ACTIVE__LOGGER: "
GET_ACTIVE__helper = \
".ds file parsed]"
GET_ACTIVE__special = \
" ["+ENTITY_ACTIVE_ENTERED.get()+"]"
print(GET_ACTIVE__LOGGER+\
GET_ACTIVE__helper+\
GET_ACTIVE__special+"\n")
LOADER_DS.load_specific(variable=\
GET_ACTIVE__LOGGER+\
GET_ACTIVE__helper+\
GET_ACTIVE__special+"\n")
# Double down (repeat stagement) on this to prevent user override.
TRUE_SEARCH_LIST.clear()
PARSED_TRUE_SEARCH_LIST.clear()
except:
IndexError
TRUE_SEARCH_LIST.clear()
PARSED_TRUE_SEARCH_LIST.clear()
print("** ENTITY SCRIPT: ORE, DETECTED ** ")
parse_it_overview = ttk.Button(ENTITY_OVERVIEW,
text='PARSE',
command=GET_OVERVIEW)
parse_it_overview.place(x=3440, y=12)
parse_it_overview.bind("<>",
GET_OVERVIEW)
def LOAD_IT():
THE_GREAT_DECIDER = ENTITY_ACTIVE_ENTERED.get()
if THE_GREAT_DECIDER.startswith('ES'):
# This will hold the stateful title so you can continue to do searches
# QUALIFIER_LOOKUP_SEED = KING_BUCKET_ENTITYSCRIPT_QUALIFIERS[0]
PULL_FILTER_ENTITYSCRIPT_QUALIFIERS()
else:
THE_GREAT_DECIDER = THE_GREAT_DECIDER[2:]
LOADED_LIST.append(PARSE_ENTITY(
ENTITY_ACTIVE_ENTERED.get()
))
KING_BUCKET_ENTITYSCRIPT_QUALIFIERS.clear()
KING_BUCKET_ENTITYSCRIPT_QUALIFIERS.append(THE_GREAT_DECIDER)
# Now working on KING_BUCKET_ENTITYSCRIPT_QUALIFIERS[0]
LABEL_ACTIVE_ENTITY_CURRENT_SLUG_LABEL.configure(text=THE_GREAT_DECIDER)
try:
if LAST_KING_SLUG[0] == None:
#*******************************************************************#
# START: ACTION - #
# [KING_SLUG_RECORDER : #
# filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT: check KING SLUG] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [KING_SLUG_RECORDER : "\
"filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT: check KING SLUG] "+\
"----------"
)
LAST_KING_SLUG.append(THE_GREAT_DECIDER)
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__LOGGER = \
"[KING_SLUG_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__LOGGER: "
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__helper = \
"check KING SLUG] "
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__values = \
"[DS SLUG LOADED: memory - "+THE_GREAT_DECIDER+"] "
print(filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__helper+\
ACTION_KING_SLUG_RECORDER(
variable=filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__LOGGER+\
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__helper+\
filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [KING_SLUG_RECORDER : "\
"filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT__LOGGER] ----------"
)
#****************************************************************** #
# STOP: ACTION - #
# [KING_SLUG_RECORDER: #
# filter_ENTITYSCRIPT_QUALIFIERS.LOAD_IT: #
# check KING SLUG] ----------" #
#***************************************************************** #
LAST_KING_SLUG.append(THE_GREAT_DECIDER)
elif LAST_KING_SLUG[0] == THE_GREAT_DECIDER:
pass
else:
z = LAST_KING_SLUG[0]
LAST_KING_SLUG.clear()
LAST_KING_SLUG.append(THE_GREAT_DECIDER)
LAST_KING_SLUG.append(z)
# The old slug now resides in THE_GREAT_DECIDER[1]
# and can be accessed again
LABEL_ACTIVE_ENTITY_LAST_SLUG_LABEL.configure(text=LAST_KING_SLUG[1])
except:
IndexError
LAST_KING_SLUG.append(THE_GREAT_DECIDER)
def PARSE_IT(event=None):
# run_progress_start()
with open(DIRDATA+ACTIVEES, 'r') as f:
for row in f:
PARSED_LIST.append(row)
f.close()
def GET_ACTIVE(event=None):
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
print("Active: Package")
LOAD_IT()
PARSE_IT()
try:
X = LOADED_LIST[0]
Y = PARSED_LIST[:]
LOADED_LIST.clear()
PARSED_LIST.clear()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT, Y)
# LOGGER: Special
GET_ACTIVE__LOGGER = \
"[GET_ACTIVE__LOGGER: "
GET_ACTIVE__helper = \
".ds file parsed]"
GET_ACTIVE__special = \
" ["+ENTITY_ACTIVE_ENTERED.get()+"]"
print(GET_ACTIVE__LOGGER+\
GET_ACTIVE__helper+\
GET_ACTIVE__special+"\n")
LOADER_DS.load_specific(variable=\
GET_ACTIVE__LOGGER+\
GET_ACTIVE__helper+\
GET_ACTIVE__special+"\n")
LOADED_LIST.clear()
PARSED_LIST.clear()
except:
IndexError
LOADED_LIST.clear()
PARSED_LIST.clear()
print("** ENTITY SCRIPT DETECTED ** ")
ENTITY_ACTIVE_ENTERED.bind('',
GET_ACTIVE)
def GET_LOG():
LOG_LIST = []
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
with open(DIRDATA+LOGES, 'r') as f:
for row in f:
LOG_LIST.append(row)
LOG_LIST.reverse()
f.close()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT, LOG_LIST)
parse_it = ttk.Button(PROGRESS_BOX,
text='PARSE',
command=GET_ACTIVE)
parse_it.place(x=2800, y=94)
parse_it.bind("<>",
GET_ACTIVE)
ttk.Button(PROGRESS_BOX,
text='STOP',
command=run_progress_stop).place(x=3000, y=94)
ttk.Button(PROGRESS_BOX,
text='LOG',
command=GET_LOG).place(x=3200, y=94)
progress_bar = ttk.Progressbar(PROGRESS_BOX,
orient='horizontal',
length=3360,
mode='determinate')
progress_bar.place(x=0, y=0)
ENTITY_SCROLLER_EMULATOR = scrolledtext.ScrolledText(
ENTITY_ACTIVE,
width=200, height=40,
wrap= ITL.WORD
)
ENTITY_SCROLLER_EMULATOR.place(x=12, y=234)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
"Active Emulation")
###########################################################
# Access Code: Filter
###########################################################
bucket_QUALIFIERS = []
bucket_QUALIFIERS_LOCATED = []
class filter_QUALIFIERS:
def pull_all_qualifiers(a):
print("LOOKUP STARTED WITH: "+a)
#*********************************************************************#
# START: ACTION - #
# [ENTITYSCRIPT_RECORDER : #
# filter_QUALIFIERS.pull_all_qualifiers: #
# record ENTITY SCRIPT search] #
#*********************************************************************#
print(
"---------- START: ACTION -" \
" [: "\
"filter_QUALIFIERS.pull_all_qualifiers: " \
"record ENTITY SCRIPT search] "+"----------"
)
if a == "":
print("Nothing was done because no input was received.")
bucket_QUALIFIERS.clear()
bucket_QUALIFIERS_LOCATED.clear()
else:
bucket_QUALIFIERS.append(a)
ENTITY_SCROLLER_OVERVIEW_IN.delete("1.0", ITL.END)
with open(ENTITY_LOCATION+SLUG_ENTITY_LEDGER, 'r') as f:
bucket_QUALIFIERS_LOCATED.append("Entities Parsed: \n")
for row in f:
print(row)
if a in row:
bucket_QUALIFIERS_LOCATED.append(row)
print(a)
else:
pass
for i in bucket_QUALIFIERS_LOCATED:
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
i
)
ENTITY_SCROLLER_OVERVIEW_IN.configure()
z = str(bucket_QUALIFIERS_LOCATED[:])
print("RAN WITH SEARCH SLUG: "+z)
bucket_QUALIFIERS_LOCATED.clear()
bucket_QUALIFIERS.clear()
f.close()
filter_QUALIFIERS.pull_all_qualifiers__LOGGER = \
"[ENTITYSCRIPT_RECORDER: "\
"filter_ENTITYSCRIPT_QUALIFIERS.pull_all_qualifiers__LOGGER: "
filter_QUALIFIERS.pull_all_qualifiers__helper = \
"record ENTITY SCRIPT search] "
filter_QUALIFIERS.pull_all_qualifiers__values = \
"[Search was ran with: - "+a+"] "
print(filter_QUALIFIERS.pull_all_qualifiers__LOGGER+\
filter_QUALIFIERS.pull_all_qualifiers__helper+\
ACTION_ENTITYSCRIPT_RECORDER(
variable=filter_QUALIFIERS.pull_all_qualifiers__LOGGER+\
filter_QUALIFIERS.pull_all_qualifiers__helper+\
filter_QUALIFIERS.pull_all_qualifiers__values
)+\
"\n"
)
print(
"---------- STOP: ACTION -" \
" [ENTITYSCRIPT_RECORDER: "\
"filter_QUALIFIERS.pull_all_qualifiers__LOGGER] ----------"
)
#*******************************************************************#
# STOP: ACTION - #
# [ENTITYSCRIPT_RECORDER: #
# filter_QUALIFIERS.pull_all_qualifiers: #
# record ENTITY SCRIPT search] ----------" #
#*******************************************************************#
def ACCESS_FIGMENTS():
PARSED_LIST_FIGMENTS = []
def get_FIGMENTS():
with open(ENTITY_LOCATION+SLUG_FIGMENT_FULL, 'r') as f:
PARSED_LIST_FIGMENTS.append("Figments Parsed: \n")
for row in f:
PARSED_LIST_FIGMENTS.append(row)
PARSED_LIST_FIGMENTS.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_FIGMENTS[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_FIGMENTS()
)
# LOGGER
get_FIGMENTS_LOGGER = "[get_FIGMENTS_LOGGER: "
get_FIGMENTS_helper = "open file]"
print(get_FIGMENTS_LOGGER+get_FIGMENTS_helper+\
ALERT_LOGGING_WARNING(
variable=get_FIGMENTS_LOGGER+get_FIGMENTS_helper
)+"\n"
)
def ACCESS_DOCUMENTS():
PARSED_LIST_DOCUMENTS = []
def get_DOCUMENTS():
with open(DOCUMENTS_LOCATION+SLUG_DOCUMENT_LEDGER, 'r') as f:
PARSED_LIST_DOCUMENTS.append("Documents Parsed: \n")
for row in f:
PARSED_LIST_DOCUMENTS.append(row)
PARSED_LIST_DOCUMENTS.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_DOCUMENTS[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_DOCUMENTS()
)
# LOGGER
get_DOCUMENTS_LOGGER = "[get_DOCUMENTS_LOGGER: "
get_DOCUMENTS_helper = "open file]"
print(get_DOCUMENTS_LOGGER+get_DOCUMENTS_helper+\
ALERT_LOGGING_WARNING(
variable=get_DOCUMENTS_LOGGER+get_DOCUMENTS_helper
)+"\n"
)
def ACCESS_PHOTOS():
PARSED_LIST_PHOTOS = []
def get_PHOTOS():
with open(DIRDATA+SLUG_ENTITY_MANIFEST, 'r') as f:
PARSED_LIST_PHOTappend("Documents Parsed: \n")
for row in f:
PARSED_LIST_PHOTappend(row)
PARSED_LIST_PHOTappend("-" * 79 +"\n")
f.close()
return(PARSED_LIST_PHOTOS[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_PHOTOS()
)
# LOGGER
get_PHOTOS_LOGGER = "[get_PHOTOS_LOGGER: "
get_PHOTOS_helper = "open file]"
print(get_PHOTOS_LOGGER+get_PHOTOS_helper+\
ALERT_LOGGING_WARNING(variable=get_PHOTOS_LOGGER+get_PHOTOS_helper
)+"\n"
)
def ACCESS_MUSIC():
ACCESS_MUSIC = "CORE ACCESS MUSIC"
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
ACCESS_MUSIC
)
# LOGGER
get_MUSIC_LOGGER = "[get_MUSIC_LOGGER: "
get_MUSIC_helper = "open file]"
print(get_MUSIC_LOGGER+get_MUSIC_helper+\
ALERT_LOGGING_WARNING(variable=get_MUSIC_LOGGER+get_MUSIC_helper)+"\n")
def ACCESS_CONTACT_BUSINESS():
PARSED_LIST_CONTACT_BUSINESS = []
def get_CONTACT_BUSINESS():
with open(DIRCONTACT+CONTACT_BUSINESS_LEDGER, 'r') as f:
PARSED_LIST_CONTACT_BUSINESS.append(
"CONTACT: Business\n"
)
for row in f:
PARSED_LIST_CONTACT_BUSINESS.append(row)
PARSED_LIST_CONTACT_BUSINESS.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_CONTACT_BUSINESS[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_CONTACT_BUSINESS()
)
# LOGGER
get_CONTACT_BUSINESS__LOGGER = "[get_CONTACT_BUSINESS__LOGGER: "
get_CONTACT_BUSINESS__helper = "open file]"
print(get_CONTACT_BUSINESS__LOGGER+get_CONTACT_BUSINESS__helper+\
ALERT_LOGGING_WARNING(variable=get_CONTACT_BUSINESS__LOGGER+\
get_CONTACT_BUSINESS__helper)+"\n")
def ACCESS_CONTACT_INDEX():
PARSED_LIST_CONTACT_INDEX = []
def get_CONTACT_INDEX():
with open(DIRCONTACT+CONTACT_INDEX_LEDGER, 'r') as f:
PARSED_LIST_CONTACT_INDEX.append(
"CONTACT: Index\n"
)
for row in f:
PARSED_LIST_CONTACT_INDEX.append(row)
PARSED_LIST_CONTACT_INDEX.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_CONTACT_INDEX[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_CONTACT_INDEX()
)
# LOGGER
get_CONTACT_INDEX__LOGGER = "[get_CONTACT_INDEX__LOGGER: "
get_CONTACT_INDEX__helper = "open file]"
print(get_CONTACT_INDEX__LOGGER+get_CONTACT_INDEX__helper+\
ALERT_LOGGING_WARNING(variable=get_CONTACT_INDEX__LOGGER+\
get_CONTACT_INDEX__helper)+"\n")
def ACCESS_EVENT_GAME_EVENTLOLLI():
PARSED_EVENT_GAME_EVENTLOLLI_LIST = []
def get_EVENT_GAME_EVENTLOLLI():
with open(EL.DATASHEET_EVENTLOLLI+EL.DS_EVENTLOLLI_GAMES, 'r') as f:
PARSED_EVENT_GAME_EVENTLOLLI_LIST.append(
"EVENT:GAME:EVENTLOLLI"
)
for row in f:
PARSED_EVENT_GAME_EVENTLOLLI_LIST.append(row)
PARSED_EVENT_GAME_EVENTLOLLI_LIST.append("-" * 79 +"\n")
f.close()
return(PARSED_EVENT_GAME_EVENTLOLLI_LIST[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
get_EVENT_GAME_EVENTLOLLI()
)
# LOGGER
get_EVENT_GAME_EVENTLOLLI__LOGGER = "[get_EVENT_GAME_EVENTLOLLI__LOGGER: "
get_EVENT_GAME_EVENTLOLLI__helper = "read event:game:eventlolli file]"
print(get_EVENT_GAME_EVENTLOLLI__LOGGER+get_EVENT_GAME_EVENTLOLLI__helper+\
ALERT_LOGGING_WARNING(variable=get_EVENT_GAME_EVENTLOLLI__LOGGER+\
get_EVENT_GAME_EVENTLOLLI__helper)+"\n")
## System Insights and Base Information Slugs
def DUMP_LOG_CORE_LOCAL():
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
MANIPULATE_OFFICIAL_ENTRY.wipe_core()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
"DUMP: CORE LOCAL"
)
def DUMP_LOG_CORE_GLOBAL():
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
MANIPULATE_OFFICIAL_ENTRY.wipe_constructed_core()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
"DUMP: CORE GLOBAL"
)
def GET_LOG_CORE_LOCAL():
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
z = GET_local_COREES_LOG()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
z
)
def GET_LOG_CORE_GLOBAL():
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
z = GET_global_CONSTRUCTEDCOREES_LOG()
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
z
)
def MAKE_CONSTRUCT_CORE_no_backup():
"""
Take the local CORE file and add it to the GLOBAL slug.
The GLOBAL slug can take routines and other qualifiers meaning
you can further parse and log certain logged types, like 'ACTION' ect.
"""
print("MAKE: CONSTRUCT CORE no backup")
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
server_add(wipe=1)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
"MADE: CONSTRUCTED_CORE without BACKUP"
)
def MAKE_CONSTRUCT_CORE_backup():
"""
Same as CONSTRUCT_CORE_no_bakcup, except a .gz is also
generated and archived on the machine at a specified location.
"""
print("MAKE: CONSTRUCT CORE backup")
ENTITY_SCROLLER_EMULATOR.delete(1.0, ITL.END)
server_add(wipe=0)
ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT,
"MADE: CONSTRUCTED_CORE with BACKUP"
)
ttk.Button(ENTITY_ACTIVE,
text='DUMP: C.ORE LOCAL',
command=DUMP_LOG_CORE_LOCAL).place(x=14, y=1700)
ttk.Button(ENTITY_ACTIVE,
text='DUMP: C.ORE GLOBAL',
command=DUMP_LOG_CORE_GLOBAL).place(x=14, y=1750)
ttk.Button(ENTITY_ACTIVE,
text='GET: CORE LOCAL',
command=GET_LOG_CORE_LOCAL).place(x=714, y=1700)
ttk.Button(ENTITY_ACTIVE,
text='GET: CORE GLOBAL',
command=GET_LOG_CORE_GLOBAL).place(x=714, y=1750)
ttk.Button(ENTITY_ACTIVE,
text='MAKE: CONSTRUCT CORE no backup',
command=MAKE_CONSTRUCT_CORE_no_backup).place(x=1414, y=1700)
ttk.Button(ENTITY_ACTIVE,
text='MAKE: CONSTRUCT CORE with backup',
command=MAKE_CONSTRUCT_CORE_backup).place(x=1414, y=1750)
## C.ORE - Quick 'passive' definitions
ACCESS_FRAME = ITL.Frame(ENTITY_ACCESS,
width=2600, height=1800,
bg='Black')
ACCESS_FRAME.place(x=0, y=0)
CORE_OPENPACKAGER = ITL.Frame(ENTITY_ACCESS,
bg='Black')
CORE_OPENPACKAGER.place(x=8, y=8)
CORE_OPENPACKAGER_LABEL = ttk.Label(CORE_OPENPACKAGER,
text="OpenPackager: Build and Share formats that make sense to you.")
CORE_OPENPACKAGER_LABEL.pack()
ENTITY_SCROLLER_OVERVIEW_IN = scrolledtext.ScrolledText(ENTITY_ACCESS,
width=150, height=40,
wrap= ITL.WORD
)
ENTITY_SCROLLER_OVERVIEW_IN.place(x=8, y=444)
# Show the retreive and cancel package mode: 'OpenPackager'
buttons_FRONTEND_INTERFACE_ACTIVE = ttk.LabelFrame(ACCESS_FRAME,
text='ACTIVE PACKAGES')
buttons_FRONTEND_INTERFACE_ACTIVE.place(x=200, y=200)
class ACCESS_QUICK_BUTTONS:
def ACCESS_ADD():
ACCESS_ADD = "ADD OBJECT"
ENTITY_SCROLLER_OVERVIEW_IN.delete(1.0,
ITL.END)
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
ACCESS_ADD)
def ACCESS_EDIT():
ACCESS_EDIT = "EDIT OBJECT"
ENTITY_SCROLLER_OVERVIEW_IN.delete(1.0,
ITL.END)
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
ACCESS_EDIT)
def ACCESS_DEL():
ACCESS_DEL = "DEL OBJECT"
ENTITY_SCROLLER_OVERVIEW_IN.delete(1.0,
ITL.END)
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
ACCESS_DEL)
NAVIGATOR_ADD = ttk.Button(ENTITY_ACCESS,
text="ADD",
command=ACCESS_QUICK_BUTTONS.ACCESS_ADD
)
NAVIGATOR_ADD.place(x=2580, y=15)
NAVIGATOR_EDIT = ttk.Button(ENTITY_ACCESS,
text="EDIT",
command=ACCESS_QUICK_BUTTONS.ACCESS_EDIT
)
NAVIGATOR_EDIT.place(x=2580, y=115)
NAVIGATOR_DELETE = ttk.Button(ENTITY_ACCESS,
text="DEL",
command=ACCESS_QUICK_BUTTONS.ACCESS_DEL
)
NAVIGATOR_DELETE.place(x=2580, y=215)
## Identity: Access Finder
# Interface with system resources: Load after authentication
from core_interface import InspectMachinePackages
def ACCESS_ALL():
ACCESS_ALL = "Not Yet Active"
ENTITY_SCROLLER_OVERVIEW_IN.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
ACCESS_ALL
)
# LOGGER
ALL_LOGGER = "[ALL_LOGGER: "
ALL_helper = "perform full setup routine]"
print(ALL_LOGGER+ALL_helper+\
ALERT_LOGGING_WARNING(variable=ALL_LOGGER+ALL_helper)+"\n")
def ACCESS_ENTITIES():
PARSED_LIST_ENTITIES = []
def get_ENTITIES():
with open(ENTITY_LOCATION+SLUG_ENTITY_LEDGER, 'r') as f:
PARSED_LIST_ENTITIES.append("Entities Parsed: \n")
for row in f:
PARSED_LIST_ENTITIES.append(row)
PARSED_LIST_ENTITIES.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_ENTITIES[:])
ENTITY_SCROLLER_OVERVIEW_IN.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
get_ENTITIES()
)
# LOGGER
get_ENTITIES_LOGGER = "[get_ENTITIES_LOGGER: "
get_ENTITIES_helper = "open file]"
print(get_ENTITIES_LOGGER+get_ENTITIES_helper+\
ALERT_LOGGING_WARNING(variable=get_ENTITIES_LOGGER+\
get_ENTITIES_helper)+"\n")
def SELECTED_RETURN(event):
print("SELECTED RETURN LOGIC:")
if ENTITY_SELECTOR_INQUISITOR.get() == "ALL":
ACCESS_ALL()
if ENTITY_SELECTOR_INQUISITOR.get() == "ENTITIES":
ACCESS_ENTITIES()
ENTITY_SELECTOR_INQUISITOR = ITL.StringVar()
ENTITY_SELECTOR_INQUISITOR = ttk.Combobox(ENTITY_ACCESS,
width=18,
textvariable=ENTITY_SELECTOR_INQUISITOR,
state='readonly'
)
ENTITY_SELECTOR_INQUISITOR['values'] = (
"ALL", "ENTITIES"
)
ENTITY_SELECTOR_INQUISITOR.place(x=2200, y=300)
ENTITY_SELECTOR_INQUISITOR.bind("<>",
SELECTED_RETURN
)
ENTITY_SELECTOR_INQUISITOR.current(0)
CORE_OPENPACKAGER_ENTITIES = ITL.Frame(ENTITY_ACCESS,
bg='Black'
)
CORE_OPENPACKAGER_ENTITIES.place(x=8, y=89)
CORE_OPENPACKAGER_ENTITIES_LABEL = ttk.Button(
CORE_OPENPACKAGER_ENTITIES,
text="Entities +",
command=ACCESS_ENTITIES
)
CORE_OPENPACKAGER_ENTITIES_LABEL.pack()
ACCESS_SEARCH_CANVAS = ITL.Canvas(ENTITY_ACCESS,
width=2100, height=100
)
ACCESS_SEARCH_CANVAS.place(x=10, y=300)
ACCESS_SEARCH_ENTRY = ITL.StringVar()
ACCESS_SEARCH_ENTRY_FIELD = ITL.Entry(ENTITY_ACCESS,
borderwidth=16,
textvariable=ACCESS_SEARCH_ENTRY,
relief= ITL.FLAT
)
ACCESS_SEARCH_ENTRY_FIELD.place(
x=20,y=310,width=2080,height=83
)
INQUISITOR_INDEX_FRAME = ITL.Frame(ENTITY_ACCESS,
bg='Black'
)
INQUISITOR_INDEX_FRAME.place(x=8, y=200)
INQUISITOR_INDEX_FRAME_LABEL = ttk.Label(INQUISITOR_INDEX_FRAME,
text="Inquisitor Index: You'll find all of your shortcuts here"
)
INQUISITOR_INDEX_FRAME_LABEL.pack()
ENTITY_SCROLLER_OVERVIEW_IN.insert(ITL.INSERT,
"Welcome to New Entity Access Portal"
)
#Button_SET_QUALIFIERS_FILTER = ttk.Button(ENTITY_ACCESS,
# text="QUALIFIERS: filter",
# command=filter_QUALIFIERS.pull_all_qualifiers
#)
#Button_SET_QUALIFIERS_FILTER.place(x=3200, y=200)
#Button_SET_QUALIFIERS_FILTER.configure()
bucket_QUALIFIERS = []
bucket_QUALIFIERS_LOCATED = []
def PULL_FILTER_QUALIFIERS(event):
a = ACCESS_SEARCH_ENTRY_FIELD.get()
filter_QUALIFIERS.pull_all_qualifiers(a)
## Finally, bind the ACCESS SEARCH ENTRY
ACCESS_SEARCH_ENTRY_FIELD.bind('',
PULL_FILTER_QUALIFIERS
)
#########################################################################
# OpenPackager: EventLolli
#########################################################################
EVENTLOLLI_FRAME = ITL.Frame(EVENTLOLLI,
width=3850, height=2000
)
EVENTLOLLI_FRAME.place(x=12, y=12)
BIG_PRIZE_FRAME = ITL.Frame(EVENTLOLLI_FRAME,
width=400, height=400,
bg='White'
)
BIG_PRIZE_FRAME.place(x=2800, y=200)
BIG_PRIZE_FRAME_TEXT = ttk.Label(EVENTLOLLI_FRAME,
text="TYPE: Ad - Display\nInteractions: 52,"\
"Est. eyes: 1113\nLinked to BIG PRIZE"
)
BIG_PRIZE_FRAME_TEXT.place(x=3250, y=200)
MEDIUM_PRIZE_FRAME = ITL.Frame(EVENTLOLLI_FRAME,
width=400, height=400,
bg='White'
)
MEDIUM_PRIZE_FRAME.place(x=2800, y=700)
MEDIUM_PRIZE_FRAME_TEXT = ttk.Label(EVENTLOLLI_FRAME,
text="Type Ad - AUDIO ALERT DISPLAY\nInteractions: 66,"\
"Est. eyes: 1562\nLinked to MEDIUM PRIZE"
)
MEDIUM_PRIZE_FRAME_TEXT.place(x=3250, y=700)
SMALL_PRIZE_FRAME = ITL.Frame(EVENTLOLLI_FRAME,
width=400, height=400,
bg='White'
)
SMALL_PRIZE_FRAME.place(x=2800, y=1200)
SMALL_PRIZE_FRAME_TEXT = ttk.Label(EVENTLOLLI_FRAME,
text="Type: Ad - Display\nInteractions: 104,"\
"Est. eyes: 2873\nLinked to SMALL PRIZE"
)
SMALL_PRIZE_FRAME_TEXT.place(x=3250, y=1200)
max_height_ad = int(400)
def window_height_logic_AD(ImagePrize):
"""
Get the height based off of the frame height
"""
# Dynamic
if (float(ImagePrize.size[1]) / max_height_ad) < 1:
return(float(ImagePrize.size[1]))
else:
return(max_height_ad)
def resized_image_width_AD(ImagePrize):
"""
Scale the width to meet the formatting provided by the frame height
"""
height = window_height_logic_AD(ImagePrize)
h_percentage = float(height) / float(ImagePrize.size[1])
w_size = float(ImagePrize.size[0]) * float(h_percentage)
return(int(w_size))
class GetPrizeLogic:
class AD_TIERS:
def get_LARGE():
ImagePrize = Image.open(EL.SLUG_AD_DEFAULT_LARGE)
ImageSized = ImagePrize.resize((
resized_image_width_AD(ImagePrize),
window_height_logic_AD(ImagePrize)),
Image.ANTIALIAS)
ImageAd = ImageTk.PhotoImage(ImageSized)
print("RAN LARGE")
LabelLargePrize = ITL.Label(EVENTLOLLI,
image=ImageAd
)
LabelLargePrize.place(x=2800, y=200)
LabelLargePrize.config(image=ImageAd)
LabelLargePrize.image = ImageAd
def get_MEDIUM():
ImagePrize = Image.open(EL.SLUG_AD_DEFAULT_MEDIUM)
ImageSized = ImagePrize.resize((
resized_image_width_AD(ImagePrize),
window_height_logic_AD(ImagePrize)),
Image.ANTIALIAS
)
ImageAdTwo = ImageTk.PhotoImage(ImageSized)
print("RAN MEDIUM")
LabelMediumPrize = ITL.Label(EVENTLOLLI, image=ImageAdTwo)
LabelMediumPrize.place(x=2800, y=700)
LabelMediumPrize.config(image=ImageAdTwo)
LabelMediumPrize.image = ImageAdTwo
def get_SMALL():
ImagePrize = Image.open(EL.SLUG_AD_DEFAULT_SMALL)
ImageSized = ImagePrize.resize((
resized_image_width_AD(ImagePrize),
window_height_logic_AD(ImagePrize)),
Image.ANTIALIAS)
ImageAdThree = ImageTk.PhotoImage(ImageSized)
print("RAN SMALL")
LabelSmallPrize = ITL.Label(EVENTLOLLI,
image=ImageAdThree
)
LabelSmallPrize.place(x=2800, y=1200)
LabelSmallPrize.config(image=ImageAdThree)
LabelSmallPrize.image = ImageAdThree
def make_LARGE():
large_prize = GetPrizeLogic.AD_TIERS.get_LARGE()
return(large_prize)
def make_MEDIUM():
medium_prize = GetPrizeLogic.AD_TIERS.get_MEDIUM()
return(medium_prize)
def make_SMALL():
small_prize = GetPrizeLogic.AD_TIERS.get_SMALL()
return(small_prize)
#******************************************************#
# START: INSTANCE 1: EVENTLOLLI #
#******************************************************#
print(
"---------- START: INSTANCE 1: EVENTLOLLI ----------"
)
make_LARGE()
make_MEDIUM()
make_SMALL()
print(
"---------- STOP: INSTANCE 1 - EVENTLOLLI ----------\n"
)
#****************************************************#
# STOP: INSTANCE 1 - EVENTLOLLI #
#****************************************************#
CORE_MAIN_HEADING = ttk.Label(EVENTLOLLI_FRAME,
text=EL.ADVERTISER_COPYRIGHT
)
CORE_MAIN_HEADING.place(x=2800, y=100)
EVENTLOLLI_PRIZE = ttk.Label(EVENTLOLLI_FRAME,
text=EL.ADVERTISER_CURRENT_TEXT
)
EVENTLOLLI_PRIZE.place(x=24, y=300)
EVENTLOLLI_PRIZE_LARGE = ttk.Label(EVENTLOLLI_FRAME,
text=EL.AD_DEFAULT_LARGE
)
EVENTLOLLI_PRIZE_LARGE.place(x=24, y=400)
EVENTLOLLI_PRIZE_MEDIUM = ttk.Label(EVENTLOLLI_FRAME,
text=EL.AD_DEFAULT_MEDIUM
)
EVENTLOLLI_PRIZE_MEDIUM.place(x=24, y=500)
EVENTLOLLI_PRIZE_SMALL = ttk.Label(EVENTLOLLI_FRAME,
text=EL.AD_DEFAULT_SMALL
)
EVENTLOLLI_PRIZE_SMALL.place(x=24, y=600)
EVENTLOLLI_SPONSOR = ttk.Label(EVENTLOLLI_FRAME,
text=EL.ADVERTISER_STATEMENT
)
EVENTLOLLI_SPONSOR.place(x=24, y=700)
#def callback():
# import webbrowser
# webbrowser.open_new(ADVERTISER_WEBSITE)
#EVENTLOLLI_SPONSOR_LINK = ITL.Label(EVENTLOLLI_FRAME,
# underline=True,
# text=EL.ADVERTISER_WEBSITE
#)
#EVENTLOLLI_SPONSOR_LINK.place(x=24, y=800)
#########################################################################
CORE_ENTITY = ttk.Label(EVENTLOLLI_FRAME,
text=EL.EVENTLOLLI_DEFAULT_TITLE
)
CORE_ENTITY.place(x=24, y=1700)
CORE_OPERATE = ttk.Label(EVENTLOLLI_FRAME,
text=EL.EVENTLOLLI_DEFAULT_DIST_TEXT
)
CORE_OPERATE.place(x=24, y=150)
#########################################################################
# C.ORE - Dynamic
#########################################################################
ENTITY_INPUT = ITL.StringVar()
ENTITY_ENTERED = ttk.Entry(EVENTLOLLI_FRAME,
width=20,
textvariable=ENTITY_INPUT
)
ENTITY_ENTERED.place(x=2300, y=14)
# Establish the cursor
ENTITY_ENTERED.focus()
ENTITY_SPINBOX_RULES_TYPE_LABEL = ttk.Label(EVENTLOLLI_FRAME,
text="SELECT THE GAME RULES "
)
ENTITY_SPINBOX_RULES_TYPE_LABEL.place(x=24, y=1200)
ENTITY_SPINBOX_RULES_TYPE = Spinbox(EVENTLOLLI_FRAME,
values=(
'Standard: Waive Liability',
'Standard: Limited Liability',
'Standard Limited Entry',
'Standard: Expires by Date',
'Standard: Kid friendly',
'Complex: Multiple Event Partners'
),
width=25,
bd=6
)
ENTITY_SPINBOX_RULES_TYPE.place(x=24, y=1250)
EVENTLOLLI_SEARCH_ENTRY = ITL.Entry(EVENTLOLLI_FRAME,
borderwidth=16, relief= ITL.FLAT
)
EVENTLOLLI_SEARCH_ENTRY.place(x=14,y=14,
width=1500, height=89
)
EVENTLOLLI_SEARCH_ENTRY.insert(ITL.INSERT,
EL.DEFAULT_AD_BUCKET
)
EVENTLOLLI_SEARCH_ENTRY.configure(font='Helvetica 22 bold')
EVENTLOLLI_BACKGROUND_ENTRY = ITL.Entry(EVENTLOLLI_FRAME,
borderwidth=16, relief= ITL.FLAT
)
EVENTLOLLI_BACKGROUND_ENTRY.place(x=14,y=1760,
width=3300, height=89
)
EVENTLOLLI_BACKGROUND_ENTRY.insert(ITL.INSERT,
RM.REMINDME_DEFAULT_BANNER
)
EVENTLOLLI_BACKGROUND_ENTRY.configure(font='Helvetica 22 bold')
ENTITY_SPINBOX_DIST_TYPE_LABEL = ttk.Label(EVENTLOLLI_FRAME,
text="SELECT DISTRIBUTION TYPE "
)
ENTITY_SPINBOX_DIST_TYPE_LABEL.place(x=24, y=1300)
ENTITY_SPINBOX_DIST_TYPE = Spinbox(EVENTLOLLI_FRAME,
values=(
'Total', 'By percent', 'Special'
),
width=25,
bd=6
)
ENTITY_SPINBOX_DIST_TYPE.place(x=24, y=1350)
ENTITY_SPINBOX_PRIZE_BIG_LABEL = ttk.Label(EVENTLOLLI_FRAME,
text="BIG PRIZES"
)
ENTITY_SPINBOX_PRIZE_BIG_LABEL.place(x=24, y=1415)
ENTITY_SPINBOX_PRIZE_BIG = Spinbox(EVENTLOLLI_FRAME,
values=(
'1', '2'
),
width=25,
bd=6
)
ENTITY_SPINBOX_PRIZE_BIG.place(x=24, y=1450)
ENTITY_SPINBOX_PRIZE_MEDIUM_LABEL = ttk.Label(EVENTLOLLI_FRAME,
text="MEDIUM PRIZES"
)
ENTITY_SPINBOX_PRIZE_MEDIUM_LABEL.place(x=24, y=1525)
ENTITY_SPINBOX_PRIZE_MEDIUM = Spinbox(EVENTLOLLI_FRAME,
values=(
'30', '40', '50'
),
width=25,
bd=6
)
ENTITY_SPINBOX_PRIZE_MEDIUM.place(x=24, y=1575)
ENTITY_SPINBOX_PRIZE_SMALL_LABEL = ttk.Label(EVENTLOLLI_FRAME,
text="SMALL PRIZES"
)
ENTITY_SPINBOX_PRIZE_SMALL_LABEL.place(x=24, y=1650)
ENTITY_SPINBOX_PRIZE_SMALL = Spinbox(EVENTLOLLI_FRAME,
values=(
'ALL', '500', '1000'
),
width=25,
bd=6
)
ENTITY_SPINBOX_PRIZE_SMALL.place(x=24, y=1700)
#########################################################################
# OpenPackager: RemindMe
#########################################################################
#******************************************************#
# START: INSTANCE 2: REMINDME #
#******************************************************#
print(
"---------- START: INSTANCE 2: REMINDME ----------"
)
print("Establishing new REMINDME directory...")
REMINDME_BOX = ITL.Frame(REMINDME,
width=3800, height=1860
)
REMINDME_BOX.place(x=12, y=110)
print(
"---------- STOP: INSTANCE 2 - REMINDME ----------\n"
)
#****************************************************#
# STOP: INSTANCE 2 - REMINDME #
#****************************************************#
def window_height_logic_gamma():
"""
Get the height based off of the frame height
"""
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
return(3000)
def resized_image_width_gamma():
"""
Scale the width to meet the formatting provided by the frame height
"""
height = window_height_logic_gamma()
h_percentage = float(height) / float(ImageGamma.size[1])
w_size = float(ImageGamma.size[0]) * float(h_percentage)
return(int(w_size))
try:
ImageNameGamma = RM.REMINDME_DEFAULT_BANNER
ImageGamma = Image.open(ImageNameGamma)
ImageSized = ImageGamma.resize((resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX,
image=PhotoImage
)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
except:
FileNotFoundError
print("Someone removed the image... Or... it's not here.")
ImageGamma = Image.open(
SLUG_BROWSEMEH_DEFAULT+BROWSEMEH_DEFAULT
)
ImageSized = ImageGamma.resize((resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX,
image=PhotoImage
)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
# Import core_interface
from core_interface import SystemTime
def update_time():
STRING_TIME = SystemTime.time_now()
REMINDME_SYSTEM_TIME.config(text=STRING_TIME,
font=("Courier", 48),
# Evalutate this function for error at least 2 times.
)
REMINDME_SYSTEM_TIME.after(1000, update_time)
REMINDME_SYSTEM_TIME = ITL.Label(REMINDME,
background ='tan', foreground='WHITE'
)
REMINDME_SYSTEM_TIME.place(x=2600, y=1600,
bordermode='outside'
)
update_time()
max_height_ad_active = int(1000)
ad_bucket = []
ad_bucket_special = []
eventlolli_title_path = EL.DEFAULT_AD_BUCKET
LabelAdActive = ITL.Label(REMINDME,
image=None
)
LabelAdActive.place(x=200, y=200)
EVENTLOLLI_ACTIVE = ['NO']
class EventLolli:
AcceptedFileTypes = [
'*.jpg', '*.JPG',
'*.png', '*.PNG',
'*.jpeg', '*.JPEG',
'*.tif', '*.TIF'
]
file_input_mechanism = []
# PIL.UnidentifiedImageError if it's 32 bit Tiff
eventlolli_title_path = EL.DEFAULT_AD_BUCKET
def path_finder_ad(eventlolli_title_path):
ad_bucket.clear()
if EventLolli.eventlolli_title_path == EL.DEFAULT_AD_BUCKET:
new_path = EL.DEFAULT_AD_BUCKET
print("Case: DEFAULT_AD_BUCKET")
else:
new_path = EventLolli.eventlolli_title_path
LabelAdActive.config(image=None)
LabelAdActive.image = None
print("Case: ACTIVE_AD")
ad_bucket.append(new_path)
curred_path = new_path
for file_accepted in EventLolli.AcceptedFileTypes:
EventLolli.file_input_mechanism.extend(
glob(curred_path+file_accepted)
)
EventLolli.file_input_mechanism.sort()
EventLolli.eventlolli_title_path = eventlolli_title_path
def window_height_logic_AD_ACTIVE(ImageActive):
"""
Get the height based off of the frame height
"""
# Dynamic
if (float(ImageActive.size[1]) / max_height_ad_active) < 1:
return(float(ImageActive.size[1]))
else:
return(max_height_ad_active)
def resized_image_width_AD_ACTIVE(ImageActive):
"""
Scale the width to meet the formatting provided by the frame height
"""
height = EventLolli.window_height_logic_AD_ACTIVE(ImageActive)
h_percentage = float(height) / float(ImageActive.size[1])
w_size = float(ImageActive.size[0]) * float(h_percentage)
return(int(w_size))
class GetActiveAdLogic:
class State:
def get_ACTIVE(ImageAdActive):
print("RAN")
LabelAdActive.config(image=ImageAdActive)
LabelAdActive.image = ImageAdActive
def make_ACTIVE_SPECIAL():
#**********************************************************************#
# START: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: SPECIAL: load image #
#**********************************************************************#
print(
"---------- START: ACTION -" \
" [Regular: EventLolli.GetActiveAdLogic.get_ACTIVE: SPECIAL: load image] " \
"----------"
)
import random
print(ad_bucket_special[:])
random_list = ad_bucket_special.copy()
PATH_COUNT_FEEDER = len(random_list)
# On a game reset, all of the conditions will need to pass through a
# guided error program as shown below. This will run correctly after a reset.
try:
path_number = random.randint(1,
PATH_COUNT_FEEDER
)
except:
ValueError
print("No index detected... Waiting for an Active Directory")
pass
# Account for the 0 index
try:
ImagePrize = Image.open(random_list[path_number-1])
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER = "[Regular: " \
"RemindMeh.GetActiveAdLogic.get_ACTIVE: "
EventLolli.GetActiveAdLogic.get_ACTIVE__helper = "SPECIAL: load image] "
EventLolli.GetActiveAdLogic.get_ACTIVE__values = "[path - "+\
ImageAdActive+"] "
print(EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
ACTION_REGULAR(variable=EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
EventLolli.GetActiveAdLogic.get_ACTIVE__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: EventLolli.GetActoveAdLogic.get_ACTIVE: SPCIAL: load image] " \
"----------"
)
#*************************************************************************#
# STOP: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: SPECIAL: load image #
#*************************************************************************#
except:
UnboundLocalError
print(
"No path_number could be established. Falling Back."
)
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER = \
"[Regular: " \
"RemindMeh.GetActiveAdLogic.get_ACTIVE: "
EventLolli.GetActiveAdLogic.get_ACTIVE__helper = \
"SPECIAL: load image] "
EventLolli.GetActiveAdLogic.get_ACTIVE__values = \
"[path - "+\
"NONE FOUND] "
print(EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
ACTION_REGULAR(variable=\
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
EventLolli.GetActiveAdLogic.get_ACTIVE__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: EventLolli.GetActoveAdLogic.get_ACTIVE: " \
"SPECIAL: load image] " \
"----------"
)
#*********************************************************************#
# STOP: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: #
# SPECIAL: load image #
#*********************************************************************#
pass
try:
ImageSized = ImagePrize.resize((
EventLolli.resized_image_width_AD_ACTIVE(ImagePrize),
EventLolli.window_height_logic_AD_ACTIVE(ImagePrize)),
Image.ANTIALIAS
)
except:
UnboundLocalError
print("No prize for an empty game...")
try:
ImageAdActive = ImageTk.PhotoImage(ImageSized)
except:
UnboundLocalError
print("No activity if there is no prize.")
try:
ad_active = EventLolli.GetActiveAdLogic.State.get_ACTIVE(
ImageAdActive
)
except:
UnboundLocalError
print("Reseed the Ad to reengage")
try:
return(ad_active)
except:
UnboundLocalError
print("-------- WIPED ---------")
def make_ACTIVE():
#*************************************************************#
# START: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: load image #
#*************************************************************#
print(
"---------- START: ACTION -" \
" [Regular: EventLolli.GetActiveAdLogic.get_ACTIVE: load image] " \
"----------"
)
import random
random_list = EventLolli.file_input_mechanism.copy()
PATH_COUNT_FEEDER = len(random_list)
# On a game reset, all of the conditions will
# need to pass through a
# guided error program as shown below.
# This will run correctly after a reset.
try:
path_number = random.randint(1,
PATH_COUNT_FEEDER
)
except:
ValueError
print("No index detected... Waiting for an Active Directory")
pass
# Account for the 0 index
try:
ImagePrize = Image.open(random_list[path_number-1])
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER = "[Regular: " \
"RemindMeh.GetActiveAdLogic.get_ACTIVE: "
EventLolli.GetActiveAdLogic.get_ACTIVE__helper = "load image] "
EventLolli.GetActiveAdLogic.get_ACTIVE__values = "[path - "+\
ImageAdActive+"] "
print(EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
ACTION_REGULAR(variable=\
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
EventLolli.GetActiveAdLogic.get_ACTIVE__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: EventLolli.GetActoveAdLogic.get_ACTIVE: load image] " \
"----------"
)
#****************************************************************#
# STOP: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: load image #
#****************************************************************#
except:
UnboundLocalError
print("No path_number could be established. Falling Back.")
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER = "[Regular: " \
"RemindMeh.GetActiveAdLogic.get_ACTIVE: "
EventLolli.GetActiveAdLogic.get_ACTIVE__helper = "load image] "
EventLolli.GetActiveAdLogic.get_ACTIVE__values = "[path - "+\
"NONE FOUND] "
print(EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
ACTION_REGULAR(variable=\
EventLolli.GetActiveAdLogic.get_ACTIVE__LOGGER+\
EventLolli.GetActiveAdLogic.get_ACTIVE__helper+\
EventLolli.GetActiveAdLogic.get_ACTIVE__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: EventLolli.GetActoveAdLogic.get_ACTIVE: load image] " \
"----------"
)
#****************************************************************#
# STOP: ACTION - #
# [Regular: RemindMeh.GetActiveAdLogic.get_ACTIVE: load image #
#****************************************************************#
pass
try:
ImageSized = ImagePrize.resize((
EventLolli.resized_image_width_AD_ACTIVE(ImagePrize),
EventLolli.window_height_logic_AD_ACTIVE(ImagePrize)),
Image.ANTIALIAS
)
except:
UnboundLocalError
print("No prize for an empty game...")
try:
ImageAdActive = ImageTk.PhotoImage(ImageSized)
except:
UnboundLocalError
print("No activity if there is no prize.")
try:
ad_active = EventLolli.GetActiveAdLogic.State.get_ACTIVE(
ImageAdActive
)
except:
UnboundLocalError
print("Reseed the Ad to reengage")
try:
return(ad_active)
except:
UnboundLocalError
print("-------- WIPED ---------")
def reseed_AD_special(eventlolli_LLB_path):
LabelAdActive.config(image=None)
LabelAdActive.image = None
ad_bucket_special.clear()
with open(SLUG_LLB_COMPACT+eventlolli_LLB_path+\
DASH_UTIL+LLBES, 'r') as \
eventlolli_LLB_reseed_values:
for line in eventlolli_LLB_reseed_values:
if line.startswith(KEY_LLB):
line = line.rsplit(KEY_LLB)[1]
cure_line_break = line.rstrip('\n')
ad_bucket_special.append(cure_line_break)
else:
pass
update_ad_special(eventlolli_LLB_path)
def reseed_AD(eventlolli_title_path):
LabelAdActive.config(image=None)
LabelAdActive.image = None
EventLolli.path_finder_ad(eventlolli_title_path)
update_ad(eventlolli_title_path)
def get_directory_AD(event=None):
# Display the active path
eventlolli_title_path = EVENTLOLLI_SEARCH_ENTRY.get()
if eventlolli_title_path.startswith(KEY_LLB_PLAIN):
print(KEY_LLB+" SLUG DETECTED")
print(KEY_LLB_PLAIN+\
' SEEDED TO: '+eventlolli_title_path
)
eventlolli_LLB_path = eventlolli_title_path
print(
'Starting multidemensional path finding... done.'
)
EventLolli.file_input_mechanism.clear()
EVENTLOLLI_ACTIVE.clear()
EVENTLOLLI_ACTIVE.append('YES')
EventLolli.reseed_AD_special(eventlolli_LLB_path)
else:
print(
'Current EventLollli Directory: '+\
str(eventlolli_title_path))
# Cleanup
EVENTLOLLI_ACTIVE.clear()
EVENTLOLLI_ACTIVE.append('YES')
EventLolli.file_input_mechanism.clear()
EventLolli.reseed_AD(eventlolli_title_path)
class END:
def all():
LabelAdActive.config(image=None)
LabelAdActive.image = None
EventLolli.file_input_mechanism.clear()
EventLolli.reseed_AD(
eventlolli_title_path='NONE: Waiting for directory'
)
ad_bucket_special.clear()
EVENTLOLLI_ACTIVE.clear()
EVENTLOLLI_ACTIVE.append('NO')
print("AD ENDED")
def update_ad_special(
eventlolli_LLB_path=EVENTLOLLI_SEARCH_ENTRY.get()):
# Populate the ad_bucket
STRING_TIME = SystemTime.time_now()
EventLolli.make_ACTIVE_SPECIAL()
# Establish the random seed
import random
base = int(EL.EVENTLOLLI_BASE)
#*******************************************************************#
# START: ACTION - #
# [Audited: EventLolli.update_ad_special: check values] #
#*******************************************************************#
print(
"---------- START: ACTION -" \
" [Audited: EventLolli.update_ad_special: check values] ----------"
)
print("Base: "+str(base))
max = int(EL.EVENTLOLLI_MAX)
print("Max: "+str(max))
update_number = random.randint(base, max)
STRING_seconds = str(float(update_number/base))
FLOAT_seconds = float(update_number/base)
INT_seconds_without_adjustment = int(FLOAT_seconds)
STRING_INT_seconds = str(INT_seconds_without_adjustment)
triple_zero = "000"
INT_seconds_for_MS = int(INT_seconds_without_adjustment+1000)
STRING_INT_seconds_adjusted = str(INT_seconds_for_MS)
print("Update time set: "+STRING_INT_seconds_adjusted+" ms")
EventLolli.update_ad_special__LOGGER = \
"[Audited: EventLolli.update_ad_special: "
EventLolli.update_ad_special__helper = \
"check values] "
EventLolli.update_ad_special__values = \
"[UNIT: ms - "+STRING_INT_seconds_adjusted+"] "
print(EventLolli.update_ad_special__LOGGER+\
EventLolli.update_ad_special__helper+\
ACTION_AUDITED(variable=EventLolli.update_ad_special__LOGGER+\
EventLolli.update_ad_special__helper+\
EventLolli.update_ad_special__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Audited: EventLolli.update_ad_special: check values] ----------"
)
#*******************************************************************#
# STOP: ACTION - #
# [Audited: EventLolli.update_ad_special: check values] ----------" #
#*******************************************************************#
if EVENTLOLLI_ACTIVE[0] == 'YES':
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad_special)
else:
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad_special)
print('The special ad cannot run because the system is shutdown.')
def update_ad(eventlolli_title_path=EventLolli.eventlolli_title_path):
eventlolli_title_path = EventLolli.eventlolli_title_path
from core_interface import SystemTime
# Populate the ad_bucket
EventLolli.path_finder_ad(eventlolli_title_path)
STRING_TIME = SystemTime.time_now()
EventLolli.make_ACTIVE()
# Establish the random seed
import random
base = int(EL.EVENTLOLLI_BASE)
#***********************************************************#
# START: ACTION - #
# [Audited: EventLolli.update_ad: check values] #
#***********************************************************#
print(
"---------- START: ACTION -" \
" [Audited: EventLolli.update_ad: check values] ----------"
)
print("Base: "+str(base))
max = int(EL.EVENTLOLLI_MAX)
print("Max: "+str(max))
update_number = random.randint(base, max)
STRING_seconds = str(float(update_number/base))
FLOAT_seconds = float(update_number/base)
INT_seconds_without_adjustment = int(FLOAT_seconds)
STRING_INT_seconds = str(INT_seconds_without_adjustment)
triple_zero = "000"
INT_seconds_for_MS = int(INT_seconds_without_adjustment+1000)
STRING_INT_seconds_adjusted = str(INT_seconds_for_MS)
print("Update time set: "+STRING_INT_seconds_adjusted+" ms")
EventLolli.update_ad__LOGGER = \
"[Audited: EventLolli.update_ad: "
EventLolli.update_ad__helper = \
"check values] "
EventLolli.update_ad__values = \
"[UNIT: ms - "+STRING_INT_seconds_adjusted+"] "
print(EventLolli.update_ad__LOGGER+\
EventLolli.update_ad__helper+\
ACTION_AUDITED(variable=EventLolli.update_ad__LOGGER+\
EventLolli.update_ad__helper+\
EventLolli.update_ad__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Audited: EventLolli.update_ad: check values] ----------"
)
#***********************************************************#
# STOP: ACTION - #
# [Audited: EventLolli.update_ad: check values] ----------" #
#***********************************************************#
if EL.EVENTLOLLI_ON == 'ON':
if EVENTLOLLI_ACTIVE[0] == 'YES':
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad)
else:
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad)
else:
if EVENTLOLLI_ACTIVE[0] == 'NO':
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad)
print("EventLolli is Off and not running either...")
else:
REMINDME_SYSTEM_TIME.after(INT_seconds_for_MS, update_ad)
class Banner:
def update_banner(event=None):
try:
REFRESH_BANNER = EVENTLOLLI_BACKGROUND_ENTRY.get()
try:
ImageNameGamma = REFRESH_BANNER
ImageGamma = Image.open(ImageNameGamma)
ImageSized = ImageGamma.resize((
resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX, image=PhotoImage)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
except:
FileNotFoundError
print("Someone removed the image... Or... it's not here.")
ImageGamma = Image.open(
SLUG_BROWSEMEH_DEFAULT+BROWSEMEH_DEFAULT
)
ImageSized = ImageGamma.resize((
resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX,
image=PhotoImage
)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
except:
IMAGE_BANNER = RM.REMINDME_DEFAULT_BANNER
try:
ImageNameGamma = IMAGE_BANNER
ImageGamma = Image.open(ImageNameGamma)
ImageSized = ImageGamma.resize((
resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX,
image=PhotoImage
)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
except:
FileNotFoundError
print("Someone removed the image... Or... it's not here.")
ImageGamma = Image.open(
SLUG_BROWSEMEH_DEFAULT+BROWSEMEH_DEFAULT
)
ImageSized = ImageGamma.resize((
resized_image_width_gamma(),
resized_image_width_gamma()),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelGamma = ITL.Label(REMINDME_BOX,
image=PhotoImage
)
LabelGamma.place(x=0, y=0)
LabelGamma.image = PhotoImage
LabelGamma.config(image=PhotoImage)
def update_banner_clean():
LabelGamma = ITL.Label(REMINDME_BOX, image=None)
LabelGamma.place(x=0, y=0)
LabelGamma.image = None
LabelGamma.config(image=None)
EVENTLOLLI_AD_OPEN = ttk.Button(EVENTLOLLI_FRAME,
text="RESEED AD",
command=EventLolli.get_directory_AD
)
EVENTLOLLI_AD_OPEN.place(x=1600, y=12)
EVENTLOLLI_AD_END = ttk.Button(EVENTLOLLI_FRAME,
text="END AD",
command=EventLolli.END.all
)
EVENTLOLLI_AD_END.place(x=1850, y=12)
EVENTLOLLI_BANNER_OPEN = ttk.Button(EVENTLOLLI_FRAME,
text="RESEED BANNER",
command=Banner.update_banner
)
EVENTLOLLI_BANNER_OPEN.place(x=2800, y=1700)
EVENTLOLLI_BANNER_CLEAR = ttk.Button(EVENTLOLLI_FRAME,
text="CLEAR BANNER",
command=Banner.update_banner_clean
)
EVENTLOLLI_BANNER_CLEAR.place(x=3080, y=1700)
EVENTLOLLI_SEARCH_ENTRY.bind('',
EventLolli.get_directory_AD
)
EVENTLOLLI_BACKGROUND_ENTRY.bind('',
Banner.update_banner
)
EVENTLOLLI_PRIZE_SMALL = ttk.Label(EVENTLOLLI_FRAME,
text="Game Name: "
)
EVENTLOLLI_PRIZE_SMALL.place(x=2100, y=14)
# To allow for member-inputs, leave off the state='readonly'
ENTITY_PROPERTY_CHOSEN = ttk.Combobox(EVENTLOLLI_FRAME,
width=15,
textvariable=ENTITY_SELECTOR_INT_TWO,
state='readonly'
)
ENTITY_PROPERTY_CHOSEN['values'] = (
'AROUND STADIUM',
'PARKING LOT',
'CONCOURSE',
'BACKYARD',
'BEACH',
'WEDDING'
)
ENTITY_PROPERTY_CHOSEN.place(x=2800, y=14)
ENTITY_PROPERTY_CHOSEN.current(0)
# To allow for member-inputs, leave off the state='readonly'
ENTITY_TEMPLATE_CHOSEN = ttk.Combobox(EVENTLOLLI_FRAME,
width=15,
textvariable=ENTITY_SELECTOR_INT_THREE,
state='readonly'
)
ENTITY_TEMPLATE_CHOSEN['values'] = (
'COLLEGE TEAM A', 'PRO TEAM A', 'FESTIVAL A'
)
ENTITY_TEMPLATE_CHOSEN.place(x=3200, y=14)
ENTITY_TEMPLATE_CHOSEN.current(0)
# To allow for member-inputs, leave off the state='readonly'
ENTITY_SELECTOR_CHOSEN = ttk.Combobox(EVENTLOLLI_FRAME,
width=15,
textvariable=ENTITY_SELECTOR_INT,
state='readonly'
)
ENTITY_SELECTOR_CHOSEN['values'] = (
1, 2, 3, 4, 5, 10, 50, 100, 500, 1000,
5000, 10000, 50000, 100000, 1000000
)
ENTITY_SELECTOR_CHOSEN.place(x=24, y=200)
ENTITY_SELECTOR_CHOSEN.current(0)
## Spinbox
def _Spinbox_OVERVIEW_A():
value = ENTITY_SPINBOX_OVERVIEW_A.get()
print(value)
ENTITY_SCROLLER_OVERVIEW.insert(ITL.INSERT, value + '\n')
#def _Spinbox_OVERVIEW_B():
# value = ENTITY_SPINBOX_OVERVIEW_B.get()
# print(value)
# ENTITY_SCROLLER_OVERVIEW.insert(ITL.INSERT, value + '\n')
EVENTLOLLI_VALUES = [
'Player 1: Entered',
'Player 2: Entered: Medium Prize Allocated',
'Player 3: Entered',
'Player 4: Entered',
'Player 5: Entered',
'Player 6: Entered',
'Player 7: Entered',
'Player 8: Entered',
'Player 9: Entered: Influencer Bonus',
'Player 10: Entered',
'Player 11: Entered',
'Player 12: Entered: Small Prize Allocated',
'Player 13: Entered',
'Player 14: Entered',
'Player 15: Entered',
'Player 16: Entered',
'Player 17: Entered',
'Player 18: Entered',
'Player 19: Entered',
'Player 20: Entered',
'Player 21: Entered',
'Player 22: Entered',
'Player 23: Entered',
'Player 24: Entered',
'Player 25: Entered',
'Player 26: Entered: Influencer Bonus: WOW, they won a Trip!'
]
ENTITY_SPINBOX_OVERVIEW_A = Spinbox(EVENTLOLLI_FRAME,
values=(EVENTLOLLI_VALUES),
width=25,
bd=6,
command=_Spinbox_OVERVIEW_A
)
ENTITY_SPINBOX_OVERVIEW_A.place(x=1950, y=100)
ENTITY_SCROLLER_OVERVIEW = scrolledtext.ScrolledText(EVENTLOLLI_FRAME,
width=120, height=47,
wrap= ITL.WORD
)
ENTITY_SCROLLER_OVERVIEW.place(x=550, y=200)
## Checked Boolean Field Definitions
# State 1: Disabled
ENTITY_BOOL_DISABLED_AUDIO = ITL.IntVar()
OPTION_DISABLED_AUDIO = ITL.Checkbutton(EVENTLOLLI_FRAME,
text="AUDIO ALERTS ENABLED",
variable=ENTITY_BOOL_DISABLED_AUDIO,
state='normal'
)
OPTION_DISABLED_AUDIO.select()
OPTION_DISABLED_AUDIO.place(x=24, y=900)
# State 1: Disabled
ENTITY_BOOL_DISABLED_VISUAL = ITL.IntVar()
OPTION_DISABLED_VISUAL = ITL.Checkbutton(EVENTLOLLI_FRAME,
text="VISUAL INCLUDED",
variable=ENTITY_BOOL_DISABLED_VISUAL,
state='normal'
)
OPTION_DISABLED_VISUAL.select()
OPTION_DISABLED_VISUAL.place(x=24, y=1000)
# State 2: Unchecked
ENTITY_BOOL_UNCHECKED_AD = ITL.IntVar()
OPTION_UNCHECKED_AD = ITL.Checkbutton(EVENTLOLLI_FRAME,
text="PROVIDE ADVERTISEMENT",
variable=ENTITY_BOOL_UNCHECKED_AD,
state='normal')
OPTION_UNCHECKED_AD.deselect()
OPTION_UNCHECKED_AD.place(x=24, y=1100)
# State 3: Checked
ENTITY_BOOL_ENABLED_CONTACT = ITL.IntVar()
OPTION_ENABLED_CONTACT = ITL.Checkbutton(EVENTLOLLI_FRAME,
text="CONTACT SUMMARY")
OPTION_ENABLED_CONTACT.place(x=24, y=1050)
class EVENTLOLLI_STATE:
def find_state():
count = 0
count_bucket = []
with open(
EL.DATASHEET_EVENTLOLLI+EL.DS_EVENTLOLLI_GAMES, 'r') as \
game_counter_EVENTLOLLI:
for lines_a in game_counter_EVENTLOLLI:
count += 1
count_bucket.append(lines_a)
if count == 1:
return(str(1))
else:
needed_game_id = count_bucket[-1]
increment_game = int(needed_game_id.split(',')[0])
return(str(increment_game+1))
game_counter_EVENTLOLLI.close()
def get_game_id():
return(EVENTLOLLI_STATE.find_state())
class EVENTLOLLI_GAME_VALUES:
game_default_text = [EL.game_default_text]
game_default_sponsor_text = [EL.game_default_sponsor_text]
brought_to_you_by = [EL.brought_to_you_by_1, EL.brought_to_you_by_2]
sponsor_access_point = [EL.sponsor_access_point_1, EL.sponsor_access_point_2]
path_ad_display_bucket = [EL.path_ad_display_bucket]
path_ad_background_display_bucket = [EL.path_ad_background_display_bucket]
eventprizes = [
EL.event_prizes_1,
EL.event_prizes_2,
EL.event_prizes_3,
EL.event_prizes_4,
EL.event_prizes_5,
EL.event_prizes_6
]
eventprizes_type = [
EL.eventprizes_type_1,
EL.eventprizes_type_2
]
eventprizes_text = [
EL.eventprizes_type_1,
EL.eventprizes_type_2,
EL.eventprizes_type_3
]
# GAME LOGIC: Fields
def scope_game_default_text():
game_default_text = EL.game_default_text[0]
return(game_default_text)
print("LOG: Game Created")
print(EL.game_default_text)
def scope_game_default_sponsor_text():
game_default_sponsor_text = EL.game_default_sponsor_text[0]
return(game_default_sponsor_text)
def scope_game_name():
game_name = ENTITY_INPUT.get()
if len(ENTITY_INPUT.get()) == 0:
return("VIRTUAL_GAME: X")
else:
return(game_name)
def scope_game_display_location():
game_display_location = ENTITY_PROPERTY_CHOSEN.get()
if len(game_display_location) == 0:
return("VIRTUAL_LOCATION: X")
else:
return(EVENTLOLLI_GAME_VALUES.game_display_location)
def scope_game_display_partner():
game_display_partner = ENTITY_TEMPLATE_CHOSEN.get()
if len(game_display_partner) == 0:
return("DEFAULT TEMPLATE")
else:
return(game_display_partner)
# Sponsored Content
def scope_brought_to_you_by():
brought_to_you_by = EVENTLOLLI_GAME_VALUES.brought_to_you_by[0]
return(brought_to_you_by)
def scope_sponsor_access_point():
sponsor_access_point = EVENTLOLLI_GAME_VALUES.sponsor_access_point[0]
return(sponsor_access_point)
# Display and Audio Paths
def scope_path_ad_display_bucket():
path_ad_display_bucket = EVENTLOLLI_GAME_VALUES.path_ad_display_bucket[0]
return(path_ad_display_bucket)
def scope_path_ad_background_display_bucket():
path_ad_background_display_bucket = EVENTLOLLI_GAME_VALUES.path_ad_background_display_bucket[0]
return(path_ad_background_display_bucket)
# Game information enhancements
def scope_audio():
audio = str(ENTITY_BOOL_DISABLED_AUDIO.get())
return(audio)
def scope_include_visual_advertisement():
include_visual_advertisement = str(ENTITY_BOOL_DISABLED_VISUAL.get())
return(include_visual_advertisement)
def scope_provide_advertiser_details():
provide_advertiser_details = str(ENTITY_BOOL_UNCHECKED_AD.get())
return(provide_advertiser_details)
def scope_provide_contact_details():
provide_contact_details = str(ENTITY_BOOL_ENABLED_CONTACT.get())
return(provide_contact_details)
# Rules
def scope_path_game_rules():
path_game_rules = ENTITY_SPINBOX_RULES_TYPE.get()
return(path_game_rules)
# Distribution Logic
def scope_distribution_type():
distribution_type = ENTITY_SPINBOX_DIST_TYPE.get()
return(distribution_type)
def scope_distribute_after_x_players():
distribute_after_x_players = str(ENTITY_SELECTOR_CHOSEN.get())
if len(distribute_after_x_players) == 0:
return("Game Ending: Manual")
else:
return(distribute_after_x_players)
# Prize Logic: Big
def scope_prize_big():
prize_big = EVENTLOLLI_GAME_VALUES.eventprizes[0]
return(prize_big)
def scope_prize_type_big():
prize_type_big = EVENTLOLLI_GAME_VALUES.eventprizes_type[0]
return(prize_type_big)
def scope_prize_help_text_big():
prize_help_text_big = EVENTLOLLI_GAME_VALUES.eventprizes_text[0]
return(prize_help_text_big)
def scope_prize_amount_big():
prize_amount_big = str(ENTITY_SPINBOX_PRIZE_BIG.get())
return(prize_amount_big)
def scope_prize_eyes_big():
prize_eyes_big = str([0])
return(prize_eyes_big)
def scope_prize_interactions_big():
prize_interactions_big = str([0])
return(prize_interactions_big)
# Prize Logic: Medium
def scope_prize_medium():
prize_medium = EVENTLOLLI_GAME_VALUES.eventprizes[2]
return(prize_medium)
def scope_prize_type_medium():
prize_type_medium = EVENTLOLLI_GAME_VALUES.eventprizes_type[1]
return(prize_type_medium)
def scope_prize_help_text_medium():
prize_help_text_medium = EVENTLOLLI_GAME_VALUES.eventprizes_text[1]
return(prize_help_text_medium)
def scope_prize_amount_medium():
prize_amount_medium = str(ENTITY_SPINBOX_PRIZE_MEDIUM.get())
return(prize_amount_medium)
def scope_prize_eyes_medium():
prize_eyes_medium = str([0])
return(prize_eyes_medium)
def scope_prize_interactions_medium():
prize_interactions_medium = str([0])
return(prize_interactions_medium)
# Prize Logic: Small
def scope_prize_small():
prize_small = EVENTLOLLI_GAME_VALUES.eventprizes[4]
return(prize_small)
def scope_prize_type_small():
prize_type_small = EVENTLOLLI_GAME_VALUES.eventprizes_type[0]
return(prize_type_small)
def scope_prize_help_text_small():
prize_help_text_small = EVENTLOLLI_GAME_VALUES.eventprizes_text[2]
return(prize_help_text_small)
def scope_prize_amount_small():
prize_amount_small = str(ENTITY_SPINBOX_PRIZE_SMALL.get())
return(prize_amount_small)
def scope_prize_eyes_small():
prize_eyes_small = str([0])
return(prize_eyes_small)
def scope_prize_interactions_small():
prize_interactions_small = str([0])
return(prize_interactions_small)
class EVENTLOLLI_GAME:
"""
Anything with scope_ is routed to a defined
.ds file. In this case, DS5000001.ds
This file will have the standard cooresponding
.entity slug to define all silos
"""
def make_default():
a = EVENTLOLLI_STATE.get_game_id()
b = scope_game_default_text()
c = scope_game_default_sponsor_text()
d = scope_game_name()
e = scope_game_display_location()
f = scope_game_display_partner()
# Sponsored Content
g = scope_brought_to_you_by()
h = scope_sponsor_access_point()
# Display and Audio Paths
i = scope_path_ad_display_bucket()
j = scope_path_ad_background_display_bucket()
# Game information enhancements
k = scope_audio()
l = scope_include_visual_advertisement()
m = scope_provide_advertiser_details()
n = scope_provide_contact_details()
# Rules
o = scope_path_game_rules()
# Distribution Logic
p = scope_distribution_type()
q = scope_distribute_after_x_players()
# Prize Logic: Big
r = scope_prize_big()
s = scope_prize_type_big()
t = scope_prize_help_text_big()
u = scope_prize_amount_big()
v = scope_prize_eyes_big()
w = scope_prize_interactions_big()
# Prize Logic: Medium
x = scope_prize_medium()
y = scope_prize_type_medium()
z = scope_prize_help_text_medium()
aa = scope_prize_amount_medium()
ab = scope_prize_eyes_medium()
ac = scope_prize_interactions_medium()
# Prize Logic: Small
ad = scope_prize_small()
ae = scope_prize_type_small()
af = scope_prize_help_text_small()
ag = scope_prize_amount_small()
ah = scope_prize_eyes_small()
ai = scope_prize_interactions_small()
# .make_scope()
print(a+", "+\
b+", "+\
c+", "+\
d+", "+\
e+", "+\
f+", "+\
# Sponsored Content
g+", "+\
h+", "+\
# Display and Audio Paths
i+", "+\
j+", "+\
# Game information enhancements
k+", "+\
l+", "+\
m+", "+\
n+", "+\
# Rules
o+", "+\
# Distribution Logic
p+", "+\
q+", "+\
# Prize Logic: Big
r+", "+\
s+", "+\
t+", "+\
u+", "+\
v+", "+\
w+", "+\
# Prize Logic: Medium
x+", "+\
y+", "+\
z+", "+\
aa+", "+\
ab+", "+\
ac+", "+\
# Prize Logic: Small
ad+", "+\
ae+", "+\
af+", "+\
ag+", "+\
ah+", "+\
ai
)
# Write line to end of DS5000001.ds
with open(
EL.DATASHEET_EVENTLOLLI+EL.DS_EVENTLOLLI_GAMES, 'a') as \
DATA_EVENTLOLLI:
DATA_EVENTLOLLI.write(
a+", "+\
b+", "+\
c+", "+\
d+", "+\
e+", "+\
f+", "+\
# Sponsored Content
g+", "+\
h+", "+\
# Display and Audio Paths
i+", "+\
j+", "+\
# Game information enhancements
k+", "+\
l+", "+\
m+", "+\
n+", "+\
# Rules
o+", "+\
# Distribution Logic
p+", "+\
q+", "+\
# Prize Logic: Big
r+", "+\
s+", "+\
t+", "+\
u+", "+\
v+", "+\
w+", "+\
# Prize Logic: Medium
x+", "+\
y+", "+\
z+", "+\
aa+", "+\
ab+", "+\
ac+", "+\
# Prize Logic: Small
ad+", "+\
ae+", "+\
af+", "+\
ag+", "+\
ah+", "+\
ai+"\n"
)
DATA_EVENTLOLLI.close()
# EventLolli Application
def click_operate():
action_operate.configure(text=\
"You're about to operate the ENTITY"
)
def click_input():
EVENTLOLLI_GAME.make_default()
action_operate.configure(text='Current Game: From - ' + \
ENTITY_PROPERTY_CHOSEN.get() +\
' ' +\
ENTITY_SELECTOR_CHOSEN.get()+' '+'MAX PLAYERS'
)
#########################################################################
# Buttons
#########################################################################
action_operate = ttk.Button(EVENTLOLLI_FRAME,
text="SETUP GAME", command=click_input
)
action_operate.place(x=1600, y=100)
# action_operate.configure(state='disabled')
#########################################################################
# Identity Locator(Navigator)
#########################################################################
IDENTITY_SEARCH_ENTRY = ITL.Entry(ENTITY_IDENTITY,
text=LOCALHOST+":"+PORTCONNECT_TO,
borderwidth=16, font=14,
relief= ITL.FLAT
)
IDENTITY_SEARCH_ENTRY.place(x=10,y=10,
width=2100, height=89
)
IDENTITY_SEARCH_ENTRY.insert(0,
LOCALHOST+":"+PORTCONNECT_TO
)
def get_current_url():
NEW_URL_SLUG = IDENTITY_SEARCH_ENTRY.get()
return(NEW_URL_SLUG)
def RETRIEVAL_NEW(event=None):
# URL_CONTENT_TO_PUT
url_slug.GO(object=get_current_url())
ENTITY_SCROLLER_IDENTITY_RENDER.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_IDENTITY_RENDER.insert(ITL.INSERT,
Slug_Bucket[-1]
)
def RETRIEVAL_LEFT():
# URL_CONTENT_TO_PUT
object_rebased = Move.left()
ENTITY_SCROLLER_IDENTITY_RENDER.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_IDENTITY_RENDER.insert(ITL.INSERT,
object_rebased
)
#NEW_URL_SLUG = IDENTITY_SEARCH_ENTRY.put(core_url.reached[-1])
def RETRIEVAL_RIGHT():
# URL_CONTENT_TO_PUT
object_rebased = Move.right()
ENTITY_SCROLLER_IDENTITY_RENDER.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_IDENTITY_RENDER.insert(ITL.INSERT,
object_rebased
)
IDENTITY_SEARCH_ENTRY.bind('',
RETRIEVAL_NEW
)
NAVIGATOR_REPULL = ttk.Button(ENTITY_IDENTITY,
text="_",
command=RETRIEVAL_NEW
)
NAVIGATOR_REPULL.place(x=2150, y=12)
NAVIGATOR_LEFT = ttk.Button(ENTITY_IDENTITY,
text="L",
command=RETRIEVAL_LEFT
)
NAVIGATOR_LEFT.place(x=2350, y=15)
NAVIGATOR_RIGHT = ttk.Button(ENTITY_IDENTITY,
text="R",
command=RETRIEVAL_RIGHT
)
NAVIGATOR_RIGHT.place(x=2550, y=15)
NAVIGATOR_SERVER = ttk.Button(ENTITY_IDENTITY,
text="(S)",
command=SERVERALPHA.NEW_MAKE_REQUESTER
)
NAVIGATOR_SERVER.place(x=2750, y=15)
GO()
ENTITY_SCROLLER_IDENTITY_RENDER = scrolledtext.ScrolledText(
ENTITY_IDENTITY,
width=160, height=50
)
ENTITY_SCROLLER_IDENTITY_RENDER.place(x=8, y=244)
ENTITY_SCROLLER_IDENTITY_RENDER.insert(ITL.INSERT,
Slug_Bucket[0]
)
#########################################################################
# Frame: Overview
#########################################################################
def get_IDENTITY():
"""
Will return the actual member according to the
core_settings operator logic
"""
with open('DATA/active_member.es', 'r') as ACTIVE_MEMBER_SETTER:
for row in ACTIVE_MEMBER_SETTER:
z = row
IDENTITY_OVERVIEW.configure(text=z)
ACTIVE_MEMBER_SETTER.close()
IDENTITY_FRAME = ITL.Frame(ENTITY_OVERVIEW,
bg='Black'
)
IDENTITY_FRAME.place(x=8, y=417)
buttons_FRONTEND_INTERFACE_IDENTITY = ttk.LabelFrame(IDENTITY_FRAME,
text='SYSTEM MEMBER'
)
buttons_FRONTEND_INTERFACE_IDENTITY.grid(column=0, row=0)
ttk.Label(buttons_FRONTEND_INTERFACE_IDENTITY,
text="Current: ").grid(column=0, row=0, sticky= ITL.W)
#IDENTITY = ttk.Label(IDENTITY_FRAME, command=get_IDENTITY)
IDENTITY_OVERVIEW = ttk.Button(IDENTITY_FRAME, text='Click for Member',
command=get_IDENTITY
)
IDENTITY_OVERVIEW.grid(column=0, row=3)
HEATER_SEARCH = ITL.StringVar()
HEATER_SEARCH = ITL.Entry(ENTITY_OVERVIEW,
relief= ITL.FLAT,
)
HEATER_SEARCH.focus()
HEATER_SEARCH.place(x=8, y=544,
height=89, width=650
)
HEATER_SEARCH.configure(
font=(
'Courier', 18, 'bold'
))
def HEATER():
global HEATER_LIST
HEATER_LIST = ITL.Frame(ENTITY_OVERVIEW,
bg='black',
height=930, width=600
)
HEATER_LIST.place(x=8, y=650)
global HEATER_LIST_10
HEATER_LIST_10 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_10.place(x=10, y=6)
global HEATER_LIST_9
HEATER_LIST_9 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_9.place(x=10, y=86)
global HEATER_LIST_8
HEATER_LIST_8 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_8.place(x=10, y=166)
global HEATER_LIST_7
HEATER_LIST_7 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_7.place(x=10, y=246)
global HEATER_LIST_6
HEATER_LIST_6 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_6.place(x=10, y=326)
global HEATER_LIST_5
HEATER_LIST_5 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_5.place(x=10, y=406)
global HEATER_LIST_4
HEATER_LIST_4 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_4.place(x=10, y=486)
global HEATER_LIST_3
HEATER_LIST_3 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_3.place(x=10, y=566)
global HEATER_LIST_2
HEATER_LIST_2 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_2.place(x=10, y=646)
global HEATER_LIST_1
HEATER_LIST_1 = ITL.Frame(HEATER_LIST,
bg='grey',
height=70, width=584
)
HEATER_LIST_1.place(x=10, y=726)
global HEATER_LIST_NAME
HEATER_LIST_NAME = ITL.Frame(HEATER_LIST,
bg='gold',
height=90, width=584
)
HEATER_LIST_NAME.place(x=10, y=806)
HEATER()
LINK_OUT = []
class LL_ACTIVE_RING:
def MAKE_LL_ACTIVE(path):
print("LL Running on path: "+path)
try:
with open(path, 'r') as fone:
for line in fone:
if line.startswith(KEY_LL_PLAIN):
try:
LINK_OUT.clear()
LL_PATH = SLUG_LL_COMPACT
LL_PATH_FULL = LL_PATH+line
LINK_OUT.append(LL_PATH_FULL)
#****************************************************#
# START: INSTANCE 4 - LOCKERLINK #
#****************************************************#
print(
"---------- START: INSTANCE 4 - LOCKERLINK ----------"
)
print(LL_PATH_FULL)
LL_FOLDER= dirname(LL_PATH_FULL)
LL_FOLDER_NAME= basename(LL_FOLDER)
HEATER_SEARCH.insert(ITL.INSERT, LL_FOLDER_NAME)
# Establish the cursor
HEATER_SEARCH.focus()
except:
UnboundLocalError
fone.close()
except:
FileNotFoundError
#****************************************************#
# START: INSTANCE 4 - LOCKERLINK #
#****************************************************#
print(
"---------- START: INSTANCE 4 - LOCKERLINK ----------"
)
print("No LL_ACTIVE: Ring specs were given.")
def rewrite(event=None):
with open(SLUG_LL_COMPACT+LL_ACTIVE_RING_LINK, 'w') as RE:
LINK_OUT.clear()
RESEED_VALUE = HEATER_SEARCH.get()
RE.write(RESEED_VALUE+DASH_UTIL+LLES)
LINK_OUT.append(SLUG_LL_COMPACT+RESEED_VALUE+DASH_UTIL+LLES)
print("Wrote LockerLink: "+RESEED_VALUE+DASH_UTIL+LLES)
LL_ASSEMBLE.LIST(event=None)
RE.close()
class LL_ASSEMBLE:
def LIST(event=None):
LL_ACTIVE_RING.MAKE_LL_ACTIVE(
path=SLUG_LL_COMPACT+LL_ACTIVE_RING_LINK
)
try:
print("LINK_OUT SET: "+LINK_OUT[0])
LL_INJECT = str(LINK_OUT[0]).strip()
except:
IndexError
print("No "+KEY_LL_PLAIN+" Slug was loaded")
try:
with open(LL_INJECT, 'r') as ftwo:
for line in ftwo:
if line.startswith("TITLE:"):
LLTITLE = line
elif line.startswith("LL1:"):
LL1 = line
elif line.startswith("LL2:"):
LL2 = line
elif line.startswith("LL3:"):
LL3 = line
elif line.startswith("LL4:"):
LL4 = line
elif line.startswith("LL5:"):
LL5 = line
elif line.startswith("LL6:"):
LL6 = line
elif line.startswith("LL7:"):
LL7 = line
elif line.startswith("LL8:"):
LL8 = line
elif line.startswith("LL9:"):
LL9 = line
elif line.startswith("LL10:"):
LL10 = line
elif line.startswith("features"):
LLFEATURES = line
print("---- Setting Current Link to: ----")
LL_ASSEMBLE_LOGGER = "[LL_ASSEMBLE: "
LL_ASSEMBLE_helper = "set link]"
print(LL_ASSEMBLE_LOGGER+LL_ASSEMBLE_helper+\
ALERT_LOGGING_WARNING(variable=\
LL_ASSEMBLE_LOGGER+LL_ASSEMBLE_helper)+"\n")
HEATER_LIST_10.destroy()
HEATER_LIST_9.destroy()
HEATER_LIST_8.destroy()
HEATER_LIST_7.destroy()
HEATER_LIST_6.destroy()
HEATER_LIST_5.destroy()
HEATER_LIST_4.destroy()
HEATER_LIST_3.destroy()
HEATER_LIST_2.destroy()
HEATER_LIST_1.destroy()
HEATER()
HEATER_LIST_10_LABEL = ttk.Label(HEATER_LIST_10,
text=LL1
)
HEATER_LIST_10_LABEL.place(x=10, y=30)
try:
HEATER_LIST_10_LABEL.configure(text="")
HEATER_LIST_10_LABEL.configure(text=LL1)
except:
pass
HEATER_LIST_9_LABEL = ttk.Label(HEATER_LIST_9,
text=LL2
)
HEATER_LIST_9_LABEL.place(x=10, y=30)
try:
HEATER_LIST_9_LABEL.configure(text="")
HEATER_LIST_9_LABEL.configure(text=LL2)
except:
pass
HEATER_LIST_8_LABEL = ttk.Label(HEATER_LIST_8,
text=LL3
)
HEATER_LIST_8_LABEL.place(x=10, y=30)
try:
HEATER_LIST_8_LABEL.configure(text="")
HEATER_LIST_8_LABEL.configure(text=LL3)
except:
pass
HEATER_LIST_7_LABEL = ttk.Label(HEATER_LIST_7,
text=LL4
)
HEATER_LIST_7_LABEL.place(x=10, y=30)
try:
HEATER_LIST_7_LABEL.configure(text="")
HEATER_LIST_7_LABEL.configure(text=LL4)
except:
pass
HEATER_LIST_6_LABEL = ttk.Label(HEATER_LIST_6,
text=LL5
)
HEATER_LIST_6_LABEL.place(x=10, y=30)
try:
HEATER_LIST_6_LABEL.configure(text="")
HEATER_LIST_6_LABEL.configure(text=LL5)
except:
pass
HEATER_LIST_5_LABEL = ttk.Label(HEATER_LIST_5,
text=LL6
)
HEATER_LIST_5_LABEL.place(x=10, y=30)
try:
HEATER_LIST_5_LABEL.configure(text="")
HEATER_LIST_5_LABEL.update()
HEATER_LIST_5_LABEL.configure(text=LL6)
except:
pass
HEATER_LIST_4_LABEL = ttk.Label(HEATER_LIST_4,
text=LL7
)
HEATER_LIST_4_LABEL.place(x=10, y=30)
try:
HEATER_LIST_4_LABEL.configure(text="")
HEATER_LIST_4_LABEL.update()
HEATER_LIST_4_LABEL.configure(text=LL7)
except:
pass
HEATER_LIST_3_LABEL = ttk.Label(HEATER_LIST_3,
text=LL8
)
HEATER_LIST_3_LABEL.place(x=10, y=30)
try:
HEATER_LIST_3_LABEL.configure(text="")
HEATER_LIST_3_LABEL.update()
HEATER_LIST_3_LABEL.configure(text=LL8)
except:
pass
HEATER_LIST_2_LABEL = ttk.Label(HEATER_LIST_2,
text=LL9
)
HEATER_LIST_2_LABEL.place(x=10, y=30)
HEATER_LIST_2_LABEL.update()
try:
HEATER_LIST_2_LABEL.configure(text=LL9)
except:
pass
HEATER_LIST_1_LABEL = ttk.Label(HEATER_LIST_1,
text=LL10
)
HEATER_LIST_1_LABEL.place(x=10, y=30)
HEATER_LIST_1_LABEL.update()
try:
HEATER_LIST_1_LABEL.configure(text=LL10)
except:
pass
LLTITLE_BAR = LLTITLE+"\n"+LLFEATURES
HEATER_LIST_NAME_LABEL = ttk.Label(HEATER_LIST_NAME,
text=LLTITLE_BAR
)
HEATER_LIST_NAME_LABEL.place(x=10, y=20)
try:
HEATER_LIST_NAME_LABEL.configure(text=LLTITLE_BAR)
HEATER_LIST_NAME_LABEL.update()
except:
pass
print("---- ACTIVE LOCKERLINK ----")
ftwo.close()
LINK_OUT.clear()
except:
FileNotFoundError
print("---- LOCKERLINK EMPTY ----")
LINK_OUT.clear()
LL_ASSEMBLE.LIST()
Button_LockerLink = ttk.Button(ENTITY_OVERVIEW,
text="LockerLink: Build",
command=LL_ACTIVE_RING.rewrite
)
Button_LockerLink.place(x=400, y=480)
HEATER_SEARCH.bind('',
LL_ACTIVE_RING.rewrite
)
print(
"---------- STOP: INSTANCE 4 - LOCKERLINK ----------\n"
)
#****************************************************#
# STOP: INSTANCE 4 - LOCKERLINK #
#****************************************************#
#########################################################################
# Frame Ring Code
#########################################################################
IDENTITY_MANAGER = []
IDENTITY_MANAGER.append("NONE")
RING_FRAME = ITL.Frame(ENTITY_RING,
bg='Black'
)
RING_FRAME.place(x=12, y=12)
# Ring Imports: System Identities and Contacts: Contacts have their own sub-system
treeRING = ttk.Treeview(RING_FRAME,
height=10
)
treeRING.pack(side='left')
treeRING_VCNKEYS = ttk.Treeview(ENTITY_RING,
height=8
)
treeRING_VCNKEYS.place(x=600, y=580)
class IDENTITY:
def EDIT_IDENTITY():
print("IDENTITY EDITOR: Loaded new Identity to edit")
def OnSingleClicktreeRING(event):
"""
Look for the default identity, if it's not there append the changer obj
"""
changer = treeRING.selection()
print('changer:', changer)
print('event:', event)
changer = treeRING.selection()[0]
print("You are now editing IDENTITY "+changer)
print("IDENTITY MANAGER: "+IDENTITY_MANAGER[0])
valueRING = treeRING.focus()
# This is the key populating item for the other related
# index values
IDENTITY_NOW = treeRING.item(treeRING.selection())['text']
# remove dissallowed characters (", ', all !@#...)
IDENTITY_NOW = IDENTITY_NOW.replace('"','')
#IDENTITY_NOW = treeRING.item(treeRING.selection())['values'][0]
#IDENTITY_NOW = treeRING.item(valueRING)
from random import randint
vcnkey_GENERATED = randint(1, 100)
IDENTITY_VCNKEY_SLUG = "NEW: "+str(vcnkey_GENERATED)
expanded_valueRING = ''
print(treeRING.item(valueRING))
IDENTITY_BASIC.delete(0, ITL.END)
IDENTITY_BASIC.insert(0, IDENTITY_NOW)
IDENTITY_VERIFIED_VCNKEY.delete(0, ITL.END)
IDENTITY_VERIFIED_VCNKEY.insert(0, IDENTITY_VCNKEY_SLUG)
with open("RING/ENTITY/ALIAS/VCN_DIRECTORY/"+IDENTITY_NOW+\
"/DEFAULT_ALIAS.vcn",'r') as RING_POPULATE:
for row in RING_POPULATE:
if row.startswith("HOST: "):
row = row.rsplit("HOST: ")[1]
RING_HOST = row.rstrip('\n')
RING_HOST_ENTRY.delete(0, ITL.END)
RING_HOST_ENTRY.insert(0, RING_HOST)
print("LOCATED->HOST: "+RING_HOST)
elif row.startswith("PORT: "):
row = row.rsplit("PORT: ")[1]
RING_PORT = row.rstrip('\n')
RING_HOST_PORT_ENTRY.delete(0, ITL.END)
RING_HOST_PORT_ENTRY.insert(0, RING_PORT)
print("LOCATED->PORT: "+RING_PORT)
elif row.startswith("USERNAME: "):
row = row.rsplit("USERNAME: ")[1]
USERNAME = row.rstrip('\n')
RING_USERNAME_ENTRY.delete(0, ITL.END)
RING_USERNAME_ENTRY.insert(0, USERNAME)
print("LOCATED->USERNAME: "+USERNAME)
elif row.startswith("KEY_HASH: "):
row = row.rsplit("KEY_HASH: ")[1]
RINGKEY = row.rstrip('\n')
RING_KEY_ENTRY.delete(0, ITL.END)
RING_KEY_ENTRY.insert(0, RINGKEY)
print("LOCATED->KEY_HASH: "+RINGKEY)
elif row.startswith("PROTOCOL: "):
row = row.rsplit("PROTOCOL: ")[1]
CONN_TYPE = row.rstrip('\n')
RING_UDP_OR_TCP_ENTRY.delete(0, ITL.END)
RING_UDP_OR_TCP_ENTRY.insert(0, CONN_TYPE)
print("LOCATED->PROTOCOL: "+CONN_TYPE)
elif row.startswith("SSL: "):
row = row.rsplit("SSL: ")[1]
SSL_ON = row.rstrip('\n')
RING_SSL_ENTRY.delete(0, ITL.END)
RING_SSL_ENTRY.insert(0, SSL_ON)
print("LOCATED->SSL: "+SSL_ON)
elif row.startswith("RANK: "):
row = row.rsplit("RANK: ")[1]
RANK = row.rstrip('\n')
RING_RANK_ENTRY.delete(0, ITL.END)
RING_RANK_ENTRY.insert(0, RANK)
print("LOCATED->RANK: "+RANK)
elif row.startswith("MAX_CONNECTIONS: "):
row = row.rsplit("MAX_CONNECTIONS: ")[1]
MAX_CONNECTIONS = row.rstrip('\n')
RING_MAX_CONNECTIONS_ENTRY.delete(0, ITL.END)
RING_MAX_CONNECTIONS_ENTRY.insert(0, MAX_CONNECTIONS)
print("LOCATED->MAX_CONNECTIONS: "+MAX_CONNECTIONS)
elif row.startswith("KEY_MASTER_LOCATION: "):
row = row.rsplit("KEY_MASTER_LOCATION: ")[1]
MASTER_A = row.rstrip('\n')
RING_KEY_LOCATION_MASTER_ENTRY.delete(0, ITL.END)
RING_KEY_LOCATION_MASTER_ENTRY.insert(0, MASTER_A)
print("LOCATED->KEY_MASTER_LOCATION: "+MASTER_A)
elif row.startswith("KEY_ACCESS_Location: "):
row = row.rsplit("KEY_ACCESS_Location: ")[1]
LOCATION_DEFAULT_KEY = row.rstrip('\n')
RING_KEY_RING_DEFAULT_PATH.delete(0, ITL.END)
RING_KEY_RING_DEFAULT_PATH.insert(0, LOCATION_DEFAULT_KEY)
print("LOCATED->KEY_ACCESS_Location: "+LOCATION_DEFAULT_KEY)
else:
print("No match")
if IDENTITY_MANAGER[0] is not changer:
IDENTITY_MANAGER.clear()
IDENTITY_MANAGER.append(changer)
IDENTITY.EDIT_IDENTITY()
else:
pass
def OnSingleClicktreeRING_VCNKEYS(event):
"""
Look for the default identity, if it's not there append the changer obj
"""
print("Selected RING_VCNKEYS: List")
treeRING.bind("<>", OnSingleClicktreeRING)
treeRING["columns"]=(
"one", "two", "three"
)
treeRING.column("#0",
width=800,
stretch= ITL.NO
)
treeRING.column("#1",
width=400,
stretch= ITL.NO)
treeRING.column("#2",
width=400,
stretch= ITL.NO)
treeRING.column("#3",
width=400,
stretch= ITL.NO)
treeRING.heading("#0",
text="IDENTITY",
anchor= ITL.W
)
treeRING.heading("#1",
text="ADMIN",
anchor= ITL.W
)
treeRING.heading("#2",
text="EDIT",
anchor= ITL.W
)
treeRING.heading("#3",
text="LAST ACTIVE",
anchor= ITL.W
)
treeRING_VCNKEYS.bind("<>", OnSingleClicktreeRING_VCNKEYS)
treeRING_VCNKEYS["columns"]=(
"one", "two"
)
treeRING_VCNKEYS.column("#0",
width=400,
stretch= ITL.NO
)
treeRING_VCNKEYS.column("#1",
width=200,
stretch= ITL.NO)
treeRING_VCNKEYS.column("#2",
width=800,
stretch= ITL.NO)
treeRING_VCNKEYS.heading("#0",
text="VCNKEY",
anchor= ITL.W
)
treeRING_VCNKEYS.heading("#1",
text="VERIFIED",
anchor= ITL.W
)
treeRING_VCNKEYS.heading("#2",
text="PUBLIC SLUG",
anchor= ITL.W
)
treeRING_VCNKEYS.insert("",
"end",
text='66HSEHNALPHNS3',
values=(
"YES",
"CORE.HOST/HSNLAHE34HNSL/hshsl3x"
)
)
treeRING_VCNKEYS.insert("",
"end",
text='XHNSEHNALPHNS3',
values=(
"YES",
"NOT AVAILABLE"
)
)
IDENTITY_PARSE_BIN = []
from core_middlelayer import ACCESS_CONTROL_PATH, ACCESS_CONTROL_DS
class IDENTITY_TREE:
def construct_tree():
with open(ACCESS_CONTROL_PATH+ACCESS_CONTROL_DS, 'r') as IDENTITY_CHECK_LIST:
next(IDENTITY_CHECK_LIST)
for row in IDENTITY_CHECK_LIST:
IDENTITY_PARSE_BIN.append(row)
i = IDENTITY_PARSE_BIN[0]
needed_data_row = [i.strip() for i in row.split(',')]
treeRING.insert("",
"end",
text=needed_data_row[2],
values=(
needed_data_row[1],
"EDIT",
needed_data_row[7]
)
)
IDENTITY_PARSE_BIN.clear()
IDENTITY_TREE.construct_tree()
#treeRING.insert(coreTreeRING1,
# "end",
# text="MASK: ANON",
# values=(
# "NO",
# "EDIT",
# "YESTERDAY"
#))
#coreTreeRING2 = treeRING.insert("",
# "end",
# text="ninjaman",
# values=(
# "SYSTEM",
# "EDIT",
# "NOW"
#))
IDENTITY_EMBLEM = ITL.Frame(ENTITY_RING,
bg='Black',
width='200',
height='200'
)
IDENTITY_EMBLEM.place(x=2100, y=44)
IDENTITY_IS_ADMIN = ITL.StringVar()
IDENTITY_IS_ADMIN = ttk.Combobox(ENTITY_RING,
width=10,
state='readonly'
)
IDENTITY_IS_ADMIN['values'] = (
"ADMIN", "SAGE", "NON PRIV", "VERIFIED"
)
IDENTITY_IS_ADMIN.place(x=2110, y=266)
IDENTITY_IS_ADMIN.current(0)
IDENTITY_BASIC_LABEL = ttk.Label(ENTITY_RING,
text="IDENTITY BASIC: "
)
IDENTITY_BASIC_LABEL.place(x=2400, y=44)
IDENTITY_BASIC = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
IDENTITY_BASIC.place(x=2400, y=89,
width=800, height=89
)
CURRENT_IDENTITY = ''
IDENTITY_BASIC.configure(font='Helvetica 14 bold',
textvariable=CURRENT_IDENTITY
)
IDENTITY_BASIC.insert(0, CURRENT_IDENTITY)
IDENTITY_VERIFIED_VCNKEY_LABEL = ttk.Label(ENTITY_RING,
text="VERIFIED VCNKEY: "
)
IDENTITY_VERIFIED_VCNKEY_LABEL.place(x=2400, y=200)
IDENTITY_VERIFIED_VCNKEY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
IDENTITY_VERIFIED_VCNKEY.place(x=2400, y=244,
width=800, height=89
)
VERIFIED_VCNKEY_IDENTITY = "VERIFIED:XH3LINH3LNSL3L"
IDENTITY_VERIFIED_VCNKEY.configure(font='Helvetica 14 bold',
textvariable = VERIFIED_VCNKEY_IDENTITY
)
IDENTITY_VERIFIED_VCNKEY.insert(0, VERIFIED_VCNKEY_IDENTITY)
KEY_TEXT_CURRENT_LABEL = ttk.Label(ENTITY_RING,
text="Current Text Key: "
)
KEY_TEXT_CURRENT_LABEL.place(x=2400, y=400)
IDENTITY_KEY_TEXT_CURRENT = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
IDENTITY_KEY_TEXT_CURRENT.place(x=2400, y=444,
width=800, height=89
)
KEY_TEXT_CURRENT = ""
IDENTITY_KEY_TEXT_CURRENT.configure(font='Helvetica 14 bold',
textvariable = KEY_TEXT_CURRENT
)
IDENTITY_KEY_TEXT_CURRENT.insert(0, KEY_TEXT_CURRENT)
KEY_TEXT_CHOSEN_LABEL = ttk.Label(ENTITY_RING,
text="Chosen Text Key: "
)
KEY_TEXT_CHOSEN_LABEL.place(x=2400, y=600)
IDENTITY_KEY_TEXT_CHOSEN = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
IDENTITY_KEY_TEXT_CHOSEN.place(x=2400, y=644,
width=800, height=89
)
KEY_TEXT_CHOSEN = ""
IDENTITY_KEY_TEXT_CHOSEN.configure(font='Helvetica 14 bold',
textvariable = KEY_TEXT_CHOSEN
)
IDENTITY_KEY_TEXT_CHOSEN.insert(0, KEY_TEXT_CHOSEN)
KEY_TEXT_CHOSEN_CONFIRM_LABEL = ttk.Label(ENTITY_RING,
text="Confirm Text Key: "
)
KEY_TEXT_CHOSEN_CONFIRM_LABEL.place(x=2400, y=800)
IDENTITY_KEY_TEXT_CHOSEN_CONFIRM = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
IDENTITY_KEY_TEXT_CHOSEN_CONFIRM.place(x=2400, y=844,
width=800, height=89
)
KEY_TEXT_CHOSEN_CONFIRM = ""
IDENTITY_KEY_TEXT_CHOSEN_CONFIRM.configure(font='Helvetica 14 bold',
textvariable = KEY_TEXT_CHOSEN_CONFIRM
)
IDENTITY_KEY_TEXT_CHOSEN_CONFIRM.insert(0, KEY_TEXT_CHOSEN_CONFIRM)
class IdentityStorageLogic():
def ADD():
print("Now adding a new Identity")
CreateMember.add_member()
def DELETE():
print("Confirm that you want to delete this Identity.")
def EDIT():
print("You are now editing the Identity.")
def SWITCH_TO():
print("Now evaluating all known contacts.")
IDENTITY_switch_to_contacts_button = ttk.Button(ENTITY_RING,
text="SWITCH TO CONTACTS",
command=IdentityStorageLogic.SWITCH_TO)
IDENTITY_switch_to_contacts_button.place(x=10, y=500)
VCNKEY_LEDGER_COMPLIANT_button = ttk.Button(ENTITY_RING,
text="LEDGER COMPLIANT",
command=IdentityStorageLogic.DELETE)
VCNKEY_LEDGER_COMPLIANT_button.place(x=2080, y=680)
VCNKEY_RESEED_button = ttk.Button(ENTITY_RING,
text="RESEED KEY",
command=IdentityStorageLogic.DELETE)
VCNKEY_RESEED_button.place(x=2080, y=780)
VCNKEY_DELETE_button = ttk.Button(ENTITY_RING,
text="DELETE KEY",
command=IdentityStorageLogic.DELETE)
VCNKEY_DELETE_button.place(x=2080, y=880)
IDENTITY_DELETE_button = ttk.Button(ENTITY_RING,
text="DELETE IDENTITYY",
command=IdentityStorageLogic.DELETE)
IDENTITY_DELETE_button.place(x=3280, y=100)
IDENTITY_ADD_button = ttk.Button(ENTITY_RING,
text="EDIT IDENTITY",
command=IdentityStorageLogic.EDIT)
IDENTITY_ADD_button.place(x=3280, y=880)
#####
CORE_ADD_MEMBER_HEADING_RING = ttk.Label(ENTITY_RING,
text='ADD MEMBER'
)
CORE_ADD_MEMBER_HEADING_RING.place(x=10, y=630)
#####
AddMemberText_RING = ttk.Label(ENTITY_RING,
text='VCNKEY'
)
AddMemberText_RING.place(x=10, y=700)
ADD_MEMBER_INPUT_RING = ITL.StringVar()
ADD_MEMBER_INPUT_RING = ttk.Entry(ENTITY_RING,
width=25,
textvariable=ADD_MEMBER_INPUT_RING
)
ADD_MEMBER_INPUT_RING.place(x=10, y=750)
# Establish the cursor
ADD_MEMBER_INPUT_RING.focus()
AddMemberAlertTextIdentity_RING = ttk.Label(ENTITY_RING,
text=' '
)
AddMemberAlertTextIdentity_RING.place(x=100, y=800)
# Key
AddMemberKeyText_RING = ttk.Label(ENTITY_RING,
text='KEY HASH'
)
AddMemberKeyText_RING.place(x=10, y=800)
ADD_MEMBER_KEY_INPUT_RING = ITL.StringVar()
ADD_MEMBER_KEY_INPUT_RING = ttk.Entry(ENTITY_RING,
show="*",
width=25,
textvariable=ADD_MEMBER_KEY_INPUT_RING
)
ADD_MEMBER_KEY_INPUT_RING.place(x=10, y=850)
# Establish the cursor
ADD_MEMBER_KEY_INPUT_RING.focus()
AddMemberAlertTextKey_RING = ttk.Label(ENTITY_RING, text=' ')
AddMemberAlertTextKey_RING.place(x=500, y=850)
#####
AddAlertText_RING = ttk.Label(ENTITY_RING
)
AddAlertText_RING.place(x=200, y=700)
IDENTITY_ADD_button = ttk.Button(ENTITY_RING,
text="ADD IDENTITY",
command=IdentityStorageLogic.ADD)
IDENTITY_ADD_button.place(x=10, y=930)
class CreateMember:
def add_member(event=None):
"""
Allows someone with access to the system to create a unpriv'd member.
If there are no members on the system yet, this will default to a dummy account until setup
"""
from core_seeker import IPDVS
IPDVS.ACCESS.add_member(
vcnkey=ADD_MEMBER_INPUT_RING.get(),
vcnkey_hash=ADD_MEMBER_KEY_INPUT_RING.get()
)
try:
invisible_object = IPDVS.BINGO_BUCKET[0]
print("MEMBER FORM ADDED")
ADD_MEMBER_INPUT_RING.delete(0, ITL.END)
ADD_MEMBER_KEY_INPUT_RING.delete(0, ITL.END)
AddAlertText_RING.configure(text="New member created")
IPDVS.BINGO_BUCKET.clear()
treeRING.delete(*treeRING.get_children())
IDENTITY_TREE.construct_tree()
treeRING.update()
except:
IndexError
print("MEMBER WAS NOT ADDED")
ADD_MEMBER_INPUT_RING.delete(0, ITL.END)
ADD_MEMBER_KEY_INPUT_RING.delete(0, ITL.END)
AddAlertText_RING.configure(
text="There was an error. \nCheck terminal output"
)
#**********************************************************#
# START: INSTANCE 5 - RING ENFORCEMENT #
#**********************************************************#
print(
"---------- START: INSTANCE 5 - RING ENFORCEMENT ----------\n"
)
from core_middlelayer import (
RING_HOST, RING_PORT, RING_USERNAME,
RING_KEY, RING_PROTOCOL, RING_SSL,
RING_RANK, RING_CONNECTIONSMAX,
RING_KEY_LOCATION_MASTER,
RING_KEY_LOCATION_ACCESS,
RING_STORAGE_STRENGTH,
RING_INSTANCE_ADD,
RING_DIRECTORY_RING_INSTANCE_PHOTO,
RING_INSTANCE_PHOTO
)
#RING_FRAME_ADMIN = ITL.Frame(ENTITY_RING,
# bg='Yellow',
# width='200',
# height='200'
#)
#RING_FRAME_ADMIN.place(x=250, y=20)
RING_KEY_SYSTEM = ITL.Frame(ENTITY_RING,
width=3700, height=900,
background="black"
)
RING_KEY_SYSTEM.place(x=30, y=1000)
RING_HOST_LABEL = ttk.Label(ENTITY_RING,
text="HOST: "
)
RING_HOST_LABEL.place(x=30, y=1040)
RING_HOST_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_HOST_ENTRY.place(x=30, y=1090,
width=1000, height=89
)
LOCAL_HOST = ''
RING_HOST_ENTRY.configure(font='Helvetica 14 bold',
textvariable=LOCAL_HOST
)
RING_HOST_ENTRY.insert(0, LOCAL_HOST)
print('LOCALHOST: '+LOCAL_HOST)
RING_PORT_LABEL = ttk.Label(ENTITY_RING,
text="PORT: "
)
RING_PORT_LABEL.place(x=30, y=1240)
RING_HOST_PORT_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_HOST_PORT_ENTRY.place(x=30, y=1290,
width=600, height=89
)
LOCAL_HOST_PORT = ''
RING_HOST_PORT_ENTRY.configure(font='Helvetica 22 bold',
textvariable=LOCAL_HOST_PORT
)
RING_HOST_PORT_ENTRY.insert(0,
LOCAL_HOST_PORT
)
print('LOCALHOST PORT: '+LOCAL_HOST_PORT)
RING_USERNAME_LABEL = ttk.Label(ENTITY_RING,
text="USERNAME: "
)
RING_USERNAME_LABEL.place(x=30, y=1450)
RING_USERNAME_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_USERNAME_ENTRY.place(x=30, y=1500,
width=1000, height=89
)
USERNAME = ''
RING_USERNAME_ENTRY.configure(font='Helvetica 22 bold',
textvariable=USERNAME
)
RING_USERNAME_ENTRY.insert(0, USERNAME)
print('USERNAME: '+USERNAME)
RING_KEY_LABEL = ttk.Label(ENTITY_RING,
text="KEY HASH: "
)
RING_KEY_LABEL.place(x=30, y=1650)
RING_KEY_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16, relief= ITL.FLAT
)
RING_KEY_ENTRY.place(x=30, y=1700,
width=1000, height=89
)
RINGKEY = ''
RING_KEY_ENTRY.configure(font='Helvetica 22 bold',
textvariable=RINGKEY
)
RING_KEY_ENTRY.insert(0, RINGKEY)
print('KEY HASH: '+RINGKEY)
RING_UDP_OR_TCP_LABEL = ttk.Label(ENTITY_RING,
text="PROTOCOL: "
)
RING_UDP_OR_TCP_LABEL.place(x=1630, y=1040)
RING_UDP_OR_TCP_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_UDP_OR_TCP_ENTRY.place(x=1630, y=1090,
width=600, height=89
)
CONN_TYPE = ''
RING_UDP_OR_TCP_ENTRY.configure(font='Helvetica 22 bold',
textvariable=CONN_TYPE
)
RING_UDP_OR_TCP_ENTRY.insert(0, CONN_TYPE)
print('CONNECTION TYPE: '+CONN_TYPE)
RING_SSL_LABEL = ttk.Label(ENTITY_RING,
text="SSL: "
)
RING_SSL_LABEL.place(x=1630, y=1240)
RING_SSL_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_SSL_ENTRY.place(x=1630, y=1290,
width=600, height=89
)
SSL_ON = ''
RING_SSL_ENTRY.configure(font='Helvetica 22 bold',
textvariable=SSL_ON
)
RING_SSL_ENTRY.insert(0, SSL_ON)
print('SSL: '+SSL_ON)
RING_RANK_LABEL = ttk.Label(ENTITY_RING,
text="RANK: "
)
RING_RANK_LABEL.place(x=1630, y=1440)
RING_RANK_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_RANK_ENTRY.place(x=1630, y=1490,
width=600, height=89
)
RANK = ''
RING_RANK_ENTRY.configure(font='Helvetica 22 bold',
textvariable=RANK
)
RING_RANK_ENTRY.insert(0,
RANK
)
print('RANK: '+RANK)
RING_MAX_CONNECTIONS_LABEL = ttk.Label(ENTITY_RING,
text="MAX CONNECTIONS: "
)
RING_MAX_CONNECTIONS_LABEL.place(x=1630, y=1650)
RING_MAX_CONNECTIONS_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_MAX_CONNECTIONS_ENTRY.place(x=1630, y=1700,
width=600, height=89
)
MAX_CONNECTIONS = ''
RING_MAX_CONNECTIONS_ENTRY.configure(font='Helvetica 22 bold',
textvariable=MAX_CONNECTIONS
)
RING_MAX_CONNECTIONS_ENTRY.insert(0, MAX_CONNECTIONS)
print('MAX CONNECTIONS: '+MAX_CONNECTIONS)
RING_KEY_LOCATION_LABEL = ttk.Label(ENTITY_RING,
text="KEY_MASTER Location: "
)
RING_KEY_LOCATION_LABEL.place(x=2400, y=1040)
RING_KEY_LOCATION_MASTER_ENTRY = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_KEY_LOCATION_MASTER_ENTRY.place(x=2400, y=1090,
width=1000, height=89
)
MASTER_A = ''
RING_KEY_LOCATION_MASTER_ENTRY.configure(font='Helvetica 14 bold',
textvariable=MASTER_A
)
RING_KEY_LOCATION_MASTER_ENTRY.insert(0, MASTER_A)
print('MASTER KEY LOCATION: '+MASTER_A)
RING_KEY_RING_DEFAULT_LABEL = ttk.Label(ENTITY_RING,
text="KEY_ACCESS Location: "
)
RING_KEY_RING_DEFAULT_LABEL.place(x=2400, y=1240)
RING_KEY_RING_DEFAULT_PATH = ITL.Entry(ENTITY_RING,
borderwidth=16,
relief= ITL.FLAT
)
RING_KEY_RING_DEFAULT_PATH.place(x=2400, y=1290,
width=1000, height=89
)
LOCATION_DEFAULT_KEY = ''
RING_KEY_RING_DEFAULT_PATH.configure(font='Helvetica 14 bold',
textvariable=LOCATION_DEFAULT_KEY
)
RING_KEY_RING_DEFAULT_PATH.insert(0,
LOCATION_DEFAULT_KEY
)
print('DEFAULT KEY ACCESS LOCATION: '+LOCATION_DEFAULT_KEY)
RING_STRENGTH_LABEL = ttk.Label(ENTITY_RING,
text="Storage Strength: "
)
RING_STRENGTH_LABEL.place(x=2400, y=1450)
ENTITY_KEY_MAKER_STRENGTH = ITL.StringVar()
ENTITY_KEY_MAKER_STRENGTH = ttk.Combobox(ENTITY_RING,
width=40,
state='readonly'
)
ENTITY_KEY_MAKER_STRENGTH['values'] = (
"plain text (none)", "md5", "sha1", "sha256", "sha512"
)
ENTITY_KEY_MAKER_STRENGTH.place(x=2400, y=1500)
#ENTITY_KEY_MAKER_STRENGTH.bind("<>",
# KEY_MAKER.SELECTED_RETURN
#)
ENTITY_KEY_MAKER_STRENGTH.current(0)
class KEY_MAKER:
"""
Make a new key at location LKNEW
"""
def reseed_key():
print("KEY PRINTED TO LOCATION: "+RING_KEY_LOCATION_MASTER)
print(RING_KEY_LOCATION_MASTER+\
" is now being MINTED with KEY-STRENGTH "+\
ENTITY_KEY_MAKER_STRENGTH.get())
with open(RING_KEY_LOCATION_MASTER, 'w') as f:
if ENTITY_KEY_MAKER_STRENGTH.get() == "plain text (none)":
print("applying plain text (none)")
f.write("HEYTHISISYOURPLAINTEXTPASSWORD")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "md5":
print("applying md5")
f.write("ABCDEFG")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha1":
print("applying sha1")
f.write("HIJKLMNO")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha256":
print("applying sha256")
f.write("PQRST")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha512":
print("applying sha512")
f.write("UVWXYZ")
print("KEY PATH: "+RING_KEY_LOCATION_MASTER+" is now being MINTED with KEY-STRENGTH "+\
ENTITY_KEY_MAKER_STRENGTH.get())
print("Done: Please update old keys now.")
def make_key():
print("KEY RESEEDED TO LOCATION: "+RING_KEY_LOCATION_ACCESS)
if ENTITY_KEY_MAKER_STRENGTH.get() == "plain text (none)":
print("Minting a new key with plain text characters (no encryption)")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "md5":
print("Minting a new key with md5 encryption")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha1":
print("Minting a new key with sha1 encryption")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha256":
print("Minting a new key with sha256 encryption")
elif ENTITY_KEY_MAKER_STRENGTH.get() == "sha512":
print("Minting a new key with sha256 encryption")
try:
copyfile(
RING_KEY_LOCATION_MASTER, RING_KEY_LOCATION_ACCESS+"KEY.es"
)
except:
FileNotFoundError
print("This path wasn't valid, so no keys were made.")
# Reseed Master Key will overwrite the master password that is checked against when a key
# has been detected. Any old keys will need to match this hash or it won't work.
RING_BUTTON_RESEED_KEY_BASE = ttk.Button(ENTITY_RING,
text="RESEED MASTER KEY",
command=KEY_MAKER.reseed_key
)
RING_BUTTON_RESEED_KEY_BASE.place(x=2400, y=1750)
RING_BUTTON_MAKE_NEW_KEY = ttk.Button(ENTITY_RING,
text="MAKE NEW KEY",
command=KEY_MAKER.make_key
)
RING_BUTTON_MAKE_NEW_KEY.place(x=2800, y=1750)
#RING_BUTTON_MAKE_NEW_KEY.bind('',
# BrowseMeh.get_directory
#)
#HASH_IN_USE = RING_STORAGE_STRENGTH
#ENTITY_KEY_MAKER_STRENGTH.configure(font='Helvetica 22 bold',
# textvariable=HASH_IN_USE
#)
#RING_STRENGTH_ENTRY.insert(0, HASH_IN_USE)
#print('HASH IN USE: '+HASH_IN_USE)
#RING_PROFILE_ADD = ttk.Label(ENTITY_RING,
#text="ADD (+)"
#)
#RING_PROFILE_ADD.place(x=50, y=225)
#RING_PROFILE_ADMIN = ttk.Label(ENTITY_RING,
# text="Admin"
#)
#RING_PROFILE_ADMIN.place(x=300, y=225)
print(
"---------- STOP: INSTANCE 5 - RING ENFORCEMENT ----------\n"
)
#**********************************************************#
# STOP: INSTANCE 5 - RING ENFORCEMENT #
#**********************************************************#
browsemeh_title_path = \
PathRetrieverBrowsemeh.get_CONSTRUCTED_PATH()
#**********************************************************#
# STOP: INSTANCE 6 - BROWSEMEH #
#**********************************************************#
print(
"---------- START: INSTANCE 6 - BROWSEMEH ----------\n"
)
BROWSEMEH_MAX_WIDTH = 2800
print("Establishing new directory...")
BROWSEMEH_SEARCH_CANVAS = ITL.Canvas(BROWSEMEH,
width=3400, height=100
)
BROWSEMEH_SEARCH_CANVAS.place(x=12, y=12)
BROWSEMEH_SEARCH_ENTRY = ITL.Entry(BROWSEMEH,
borderwidth=16,
relief= ITL.FLAT
)
BROWSEMEH_SEARCH_ENTRY.place(x=14,y=14,
width=2100, height=89
)
BROWSEMEH_SEARCH_ENTRY.configure(font='Helvetica 22 bold')
max_height = 1600
BROWSEMEH_BOX = ITL.Frame(BROWSEMEH,
height=1800
)
BROWSEMEH_BOX.place(x=12, y=110)
ListboxTitles = ITL.Listbox(BROWSEMEH_BOX)
ListboxTitles.pack(side="left",
expand=0,
fill= ITL.BOTH
)
BROWSEMEH_TITLE = ttk.Label(BROWSEMEH,
text="BrowseMeh Version 1.0"
)
BROWSEMEH_TITLE.place(x=14, y=1742)
BROWSEMEH_COUNTER = ttk.Label(BROWSEMEH,
text="Add a path with pictures to get started"
)
BROWSEMEH_COUNTER.place(x=14, y=1782)
browsemeh_title_path = BM.SLUG_BROWSEMEH
ImageBeta = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
BROWSEMEH_ORIGINAL_SIZE_NOW = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_ORIGINAL_SIZE_NOW.place(x=2470, y=1742)
BROWSEMEH_ORIGINAL_SIZE_THEN = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_ORIGINAL_SIZE_THEN.place(x=2600, y=1742)
BROWSEMEH_ORIGINAL_SIZE_WIDTH = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_ORIGINAL_SIZE_WIDTH.place(x=1030, y=1782)
BROWSEMEH_ORIGINAL_SIZE_HEIGHT = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.place(x=1228, y=1782)
BROWSEMEH_NOW_SIZE_WIDTH = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_NOW_SIZE_WIDTH.place(x=622, y=1782)
BROWSEMEH_NOW_SIZE_HEIGHT = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_NOW_SIZE_HEIGHT.place(x=820, y=1782)
BROWSEMEH_COMPRESSION_RATIO = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_COMPRESSION_RATIO.place(x=1490, y=1782)
BROWSEMEH_BLOCK_LOADED = ttk.Label(BROWSEMEH,
text=""
)
BROWSEMEH_BLOCK_LOADED.place(x=2470, y=1782)
#Main Special Operations Box: Entity Compound
ENTITY_COMPOUND = ITL.Frame(BROWSEMEH)
ENTITY_COMPOUND.place(x=-1000, y=-1000)
# Special Operators: Use these to create custom use case functions for various system properties if object_state is 1, this won't run. This
# prevents dangerous potentially seizure causing glitches
class_method = 0
class SPECIAL_ACCESS:
special_access_bucket_write_to_pattern = []
special_access_bucket_photo_path = []
class STATE_DECIDE:
object_state = 0
TEMPDIRECTORY_bucket = []
#class OPERATE:
# def hide():
# ENTITY_COMPOUND.place(x=-1000, y=-1000)
# ENTITY_COMPOUND.update()
#shutil.rmtree(TEMPDIRECTORY_bucket[0])
# ENTITY_COMPOUND.destroy()
class Main:
frame_bucket = []
# You can set a default or not
#state_checker = ["NOT ACTIVE"]
state_checker = []
FRAME_ZERO_BUCKET = []
FRAME_EFN_BUCKET = []
FRAME_IMAGE_NAME_BUCKET = []
number_counter_object = 0
state_generator = 1
class SPECIAL_DECISION:
def make_decision(class_method=class_method):
if class_method=="EXCEPTION":
print("Stop exception Received")
Main.state_checker.clear()
Main.state_checker.append("NOT ACTIVE")
else:
try:
Main.state_checker[0] == "NOT ACTIVE"
print("CURRENT FRAME STATUS: "+Main.state_checker[0])
OBJECT_STATE.move_object()
print("RAN OBJECT MAP")
except:
IndexError
print("Gif was recently restarted")
try:
Main.state_checker[0] == "ACTIVE"
print("Nothing happened, thanks.")
except:
IndexError
print("This was once a stateful sequential image file")
def on_replay_press():
if Main.state_checker[0] == "ACTIVE":
print("Warning: Don't load sequential formats too quickly, it can hurt your eyes.")
else:
MACRO.gif_macro(
ImageSized= Main.FRAME_ZERO_BUCKET[0],
ExtractFileName= Main.FRAME_EFN_BUCKET[0],
ImageName = Main.FRAME_IMAGE_NAME_BUCKET[0]
)
class FRAME:
frame_state_bucket = 0
def grab_frame_stop():
FRAME.frame_state_bucket += 1
if Main.state_checker[0] == "NOT ACTIVE":
if FRAME.frame_state_bucket > 1:
pass
else:
if FRAME.frame_state_bucket > 1:
SPECIAL_DECISIONS.make_decision(class_method="EXCEPTION")
FRAME.frame_state_bucket = 0
Main.frame_bucket.clear()
print("Already stopped this animation.")
else:
pass
#destroy_gif_player = ttk.Button(
# ENTITY_COMPOUND,
# text = "Hide",
# command=OPERATE.hide
#)
#destroy_gif_player.pack()
class FRAME_MASTER:
def disect_all_frames():
title = Main.FRAME_EFN_BUCKET[0]
slug_OUTPUT = title+"-%d.png"
frame_bin = "IDENTITY/PHOTO/frames/"
SLUG_sequence_gif = Image.open(Main.FRAME_IMAGE_NAME_BUCKET[0])
last_frame = None
state_generator = 1
for frame in ImageSequence.Iterator(Main.FRAME_ZERO_BUCKET[0]):
frame.save(frame_bin+slug_OUTPUT % state_generator)
state_generator += 1
print("Wrote a sequential image file to: "+frame_bin)
replay_frames = ttk.Button(
ENTITY_COMPOUND,
text = "Replay",
command=on_replay_press
)
replay_frames.pack()
stop_frames = ttk.Button(
ENTITY_COMPOUND,
text = "Stop",
command=grab_frame_stop
)
stop_frames.pack()
unstack_frames = ttk.Button(
ENTITY_COMPOUND,
text = "Unstack",
command=FRAME_MASTER.disect_all_frames
)
unstack_frames.pack()
class OBJECT_STATE:
def move_object(class_method=class_method):
try:
Main.frame_bucket[0]
Main.state_checker.clear()
Main.state_checker.append("ACTIVE")
print("A sequential image file began to load. Status: "+Main.state_checker[0])
try:
frame = Main.frame_bucket[class_method]
class_method += 1
LabelBeta.configure(image=frame)
LabelBeta.after(100, OBJECT_STATE.move_object, class_method)
except:
IndexError
LabelBeta.configure(image=Main.frame_bucket[0])
Main.state_checker.clear()
print("Gif Exhausted")
class_method = 0
STATE_DECIDE.object_state = 0
Main.state_checker.clear()
Main.state_checker.append("NOT ACTIVE")
except:
#_tkinter.TclError
IndexError
print("Someone stopped the frame...")
if Main.state_checker[0] == "ACTIVE":
LabelBeta.configure(image=Main.frame_bucket[0])
Main.state_checker.clear()
Main.state_checker.append("NOT ACTIVE")
else:
Main.state_checker.clear()
Main.state_checker.append("NOT ACTIVE")
print("Done...")
LabelBeta.configure(image=Main.frame_bucket[0])
LabelBeta.update()
class MACRO:
def gif_macro(ImageSized, ExtractFileName, ImageName):
SPECIAL_OPERATORS.construct.do(
ImageSized,
ExtractFileName,
ImageName
)
LabelBeta.after(0, SPECIAL_DECISION.make_decision, 0)
useable_bucket = []
class SPECIAL_OPERATORS:
class construct:
def do(ImageSized, ExtractFileName, ImageName):
Main.frame_bucket.clear()
Main.state_generator = 0
print("DID IT, 'LabelBeta' was AUGMENTED")
photo_path = ImageName
write_to_pattern = ExtractFileName+"_"+"%d.png"
SPECIAL_ACCESS.special_access_bucket_write_to_pattern.clear()
SPECIAL_ACCESS.special_access_bucket_photo_path.clear()
SPECIAL_ACCESS.special_access_bucket_write_to_pattern.append(write_to_pattern)
SPECIAL_ACCESS.special_access_bucket_photo_path.append(photo_path)
print("Making special Operations Case: Special Image Detected")
print("Building special case now...")
print("Wrote "+\
SPECIAL_ACCESS.special_access_bucket_write_to_pattern[0]+" as the pattern"
)
print("Wrote "+\
SPECIAL_ACCESS.special_access_bucket_photo_path[0]+" as the file in Memory"
)
# Startup sequence
SLUG_sequence_gif = ImageSized
print(SLUG_sequence_gif.is_animated)
print(SLUG_sequence_gif.n_frames)
#print("GOT: "+str(counter_object))
TEMPDIRECTORYPATH = mkdtemp()
print("MADE TEMPDIRECTORYPATH")
first_dir = getcwd()
print(str(first_dir))
chdir(TEMPDIRECTORYPATH)
print(getcwd())
write_to_operator_pattern = \
SPECIAL_ACCESS.special_access_bucket_write_to_pattern[0]
counter_slug = \
SPECIAL_ACCESS.special_access_bucket_photo_path[0]
#counter_object = \
#PhotoImage(file=counter_slug)
for frame in ImageSequence.Iterator(SLUG_sequence_gif):
frame.save(write_to_operator_pattern % Main.state_generator)
Main.state_generator += 1
useable_bucket.append(
write_to_operator_pattern % Main.state_generator
)
pin_counter_object = 0
for i in range(pin_counter_object, SLUG_sequence_gif.n_frames):
# a = PhotoImage(file=photo_path, format="gif -index {}".format(i))
try:
a = ITL.PhotoImage(file=useable_bucket[Main.number_counter_object])
Main.frame_bucket.append(a)
Main.number_counter_object += 1
print("ADDED"+str(a))
except:
_tkinter.TclError
print("Frames Exhausted")
break
useable_bucket.clear()
chdir(first_dir)
rmtree(TEMPDIRECTORYPATH)
Main.number_counter_object = 0
print(Main.frame_bucket[:])
print("Frames calculated: "+str(Main.state_generator))
Main.state_checker.clear()
LabelBeta.config(image=Main.frame_bucket[0])
LabelBeta.image = Main.frame_bucket[0]
Main.state_checker.append("NOT ACTIVE")
print("CURRENT STATUS: "+Main.state_checker[0])
#SPECIAL_DECISION.make_decision(class_method=class_method)
# This will store the current full-frame image
class ACTIVE_MANIPULATOR:
manipulator_bucket = []
class IMAGE_SLUG_OPTION:
manipulator_new_slug = []
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
class COMPRESSION:
compression_ratio_bucket = []
class ACTIVE_BASE_BYTES:
base_byte_value_bucket = []
class SPECIAL_IMPORTS:
# To store comparison ratios
BUCKET_ORIGIN = []
def BETA_window_height_logic(ImageBeta):
"""
Get the height based off of the frame height
"""
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.configure(text="x "+\
STRING_HEIGHT_ORIGINAL+"H"
)
BROWSEMEH_ORIGINAL_SIZE_WIDTH.configure(text=\
STRING_WIDTH_ORIGINAL+"W"
)
if (float(HEIGHT_ORIGINAL) / float(max_height)) < 1:
"""
This is for images that are smaller than the max height allowed
"""
SCALE_CAPPER = 2
if WIDTH_ORIGINAL >= BROWSEMEH_MAX_WIDTH:
"""
This is for images smaller than max-height, but taller than max-width
"""
if float(WIDTH_ORIGINAL) > float(SCALE_CAPPER*BROWSEMEH_MAX_WIDTH):
"""
We can set a basic threshold here for Extra wide images.
"""
subscript_divisor = WIDTH_ORIGINAL - BROWSEMEH_MAX_WIDTH
subscript_value = float(subscript_divisor/WIDTH_ORIGINAL)
z = int(float(float(1-subscript_value)*HEIGHT_ORIGINAL))
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 1")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
# z is height and
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
#print("Extra-wid Image detected")
return(z)
else:
"""
Wide, but not wider than the threshold
"""
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 2")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
STRING_HEIGHT_ORIGINAL+"H"
)
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(int(float(HEIGHT_ORIGINAL)))
#print("Delivered a normal-sized image")
else:
if int(WIDTH_ORIGINAL) > SCALE_CAPPER*BROWSEMEH_MAX_WIDTH:
"""
Test the threshold for a High, and Wide image
"""
subscript_divisor = WIDTH_ORIGINAL - BROWSEMEH_MAX_WIDTH
subscript_value = float(subscript_divisor/WIDTH_ORIGINAL)
z = int(float(float(1-subscript_value)*HEIGHT_ORIGINAL))
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 3")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
#print("Scaled Down Extra-High and Wide image to Height: "+str(z))
return(z)
elif int(WIDTH_ORIGINAL) > BROWSEMEH_MAX_WIDTH:
subscript_divisor = WIDTH_ORIGINAL - BROWSEMEH_MAX_WIDTH
subscript_value = float(subscript_divisor/WIDTH_ORIGINAL)
z = int(float(float(1-subscript_value)*HEIGHT_ORIGINAL))
print("Scaled Down Normal-sized Large Image to: "+z)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 4")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(z)
else:
return(HEIGHT_ORIGINAL)
else:
if WIDTH_ORIGINAL <= BROWSEMEH_MAX_WIDTH:
"""
This is a tall and slim Image
"""
z = int(max_height)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 5")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(int(z))+"H"
)
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
# print("Regular Size of: "+WIDTH_ORIGINAL)
return(z)
else:
subscript_divisor = WIDTH_ORIGINAL - BROWSEMEH_MAX_WIDTH
subscript_value = float(subscript_divisor/WIDTH_ORIGINAL)
z = int(float(float(1-subscript_value)))
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 6")
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z*HEIGHT_ORIGINAL)+"H")
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(z)
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
def BETA_resized_image_width(ImageBeta):
"""
Scale the width to meet the formatting provided by the frame height
"""
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
height = SPECIAL_IMPORTS.BETA_window_height_logic(ImageBeta)
h_percentage = float(height) / float(HEIGHT_ORIGINAL)
w_size = float(WIDTH_ORIGINAL) * float(h_percentage)
z = int(float(w_size))
if int(w_size) > BROWSEMEH_MAX_WIDTH:
# print("EXTRA WIDE IMAGE Detected")
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 7")
BROWSEMEH_NOW_SIZE_WIDTH.configure(text=\
str(z)+"W"
)
DERIVATIVE_AREA_WIDTH = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_WIDTH)
DERIVATIVE_AREA = \
SPECIAL_IMPORTS.BUCKET_ORIGIN[0]*SPECIAL_IMPORTS.BUCKET_ORIGIN[1]
COMPRESSION_RATIO = DERIVATIVE_AREA/ORIGIN_AREA
COMPRESSION.compression_ratio_bucket.clear()
COMPRESSION.compression_ratio_bucket.append(COMPRESSION_RATIO)
BROWSEMEH_COMPRESSION_RATIO.configure(text="Compression Ratio: "+\
str(COMPRESSION_RATIO)
)
return(z)
else:
z = int(w_size)
# print("Normal Large Image Detected")
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 8")
BROWSEMEH_NOW_SIZE_WIDTH.configure(text=\
str(z)+"W"
)
DERIVATIVE_AREA_WIDTH = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_WIDTH)
DERIVATIVE_AREA = \
SPECIAL_IMPORTS.BUCKET_ORIGIN[0]*SPECIAL_IMPORTS.BUCKET_ORIGIN[1]
COMPRESSION_RATIO = DERIVATIVE_AREA/ORIGIN_AREA
COMPRESSION.compression_ratio_bucket.clear()
COMPRESSION.compression_ratio_bucket.append(COMPRESSION_RATIO)
BROWSEMEH_COMPRESSION_RATIO.configure(text="Compression Ratio: "+\
str(COMPRESSION_RATIO)
)
return(z)
def window_height_logic(ImageBeta):
"""
Get the height based off of the frame height
"""
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.configure(text=\
"x "+STRING_WIDTH_ORIGINAL+\
"H"
)
if (float(HEIGHT_ORIGINAL) / max_height) < 1:
if SPECIAL_IMPORTS.BETA_resized_image_width(ImageBeta) < \
BROWSEMEH_MAX_WIDTH:
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
STRING_HEIGHT_ORIGINAL+"H"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 9")
# z is height and
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = HEIGHT_ORIGINAL
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(float(HEIGHT_ORIGINAL))
else:
z = int(float(HEIGHT_ORIGINAL/3))
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 10")
# z is height and
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(z)
else:
z = int(float(max_height/3))
if SPECIAL_IMPORTS.BETA_resized_image_width(ImageBeta) > \
BROWSEMEH_MAX_WIDTH:
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 11")
# z is height and
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(z)
else:
z = int(max_height)
BROWSEMEH_NOW_SIZE_HEIGHT.configure(text="x "+\
str(z)+"H"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 12")
# z is height and
SPECIAL_IMPORTS.BUCKET_ORIGIN.clear()
DERIVATIVE_AREA_HEIGHT = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_HEIGHT)
return(z)
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
def resized_image_width(ImageBeta):
"""
Scale the width to meet the formatting provided by the frame height
"""
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.configure(text=\
"x "+STRING_WIDTH_ORIGINAL+"W")
height = window_height_logic(ImageBeta)
h_percentage = float(height) / float(HEIGHT_ORIGINAL)
w_size = float(WIDTH_ORIGINAL) * float(h_percentage)
z = int(float(w_size))
if int(w_size) > BROWSEMEH_MAX_WIDTH:
BROWSEMEH_NOW_SIZE_WIDTH.configure(text=\
str(z)+"W"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 13")
DERIVATIVE_AREA_WIDTH = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_WIDTH)
DERIVATIVE_AREA = \
SPECIAL_IMPORTS.BUCKET_ORIGIN[0]*SPECIAL_IMPORTS.BUCKET_ORIGIN[1]
COMPRESSION_RATIO = \
DERIVATIVE_AREA/ORIGIN_AREA
COMPRESSION.compression_ratio_bucket.clear()
COMPRESSION.compression_ratio_bucket.append(COMPRESSION_RATIO)
BROWSEMEH_COMPRESSION_RATIO.configure(text="Compression Ratio: "+\
str(COMPRESSION_RATIO)
)
return(z)
else:
BROWSEMEH_NOW_SIZE_WIDTH.configure(text=\
str(z)+"W"
)
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 14")
DERIVATIVE_AREA_WIDTH = z
SPECIAL_IMPORTS.BUCKET_ORIGIN.append(DERIVATIVE_AREA_WIDTH)
DERIVATIVE_AREA = \
SPECIAL_IMPORTS.BUCKET_ORIGIN[0]*SPECIAL_IMPORTS.BUCKET_ORIGIN[1]
COMPRESSION_RATIO = DERIVATIVE_AREA/ORIGIN_AREA
COMPRESSION.compression_ratio_bucket.clear()
COMPRESSION.compression_ratio_bucket.append(COMPRESSION_RATIO)
BROWSEMEH_COMPRESSION_RATIO.configure(text="Compression Ratio: "+\
str(COMPRESSION_RATIO)
)
return(int(w_size))
def window_height_logic_alpha(ImageAlpha):
"""
Get the height based off of the frame height
"""
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
if (float(ImageAlpha.size[1]) / max_height) < 1:
if resized_image_width(ImageAlpha) < BROWSEMEH_MAX_WIDTH:
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 5")
return(float(ImageAlpha.size[1]))
else:
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 16")
return(int(float(ImageAlpha.size[1]/3)))
else:
if resized_image_width(ImageAlpha) > BROWSEMEH_MAX_WIDTH:
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 17")
return(int(float(max_height/3)))
else:
return(int(max_height))
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 18")
def resized_image_width_alpha(ImageAlpha):
"""
Scale the width to meet the formatting provided by the frame height
"""
height = window_height_logic_alpha(ImageAlpha)
h_percentage = float(height) / float(ImageAlpha.size[1])
w_size = float(ImageAlpha.size[0]) * float(h_percentage)
if int(w_size) > BROWSEMEH_MAX_WIDTH:
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 19")
return(int(float(w_size)/3))
else:
BROWSEMEH_BLOCK_LOADED.configure(text="Case: 20")
return(int(w_size))
try:
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((
resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
Alpha_PhotoImage = ImageTk.PhotoImage(ImageSized)
except:
FileNotFoundError
print("No Slug Loaded: Someone removed the image... Or... it's not here.")
ImageMB = float(getsize(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
Alpha_PhotoImage = ImageTk.PhotoImage(ImageSized)
ImageSized = ImageBeta.resize((resized_image_width(ImageBeta),
window_height_logic(ImageBeta)),
Image.ANTIALIAS
)
class ExportBucket:
default_export_bucket = []
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta = ITL.Label(BROWSEMEH_BOX, image=PhotoImage)
LabelBeta.pack(side="left")
title_bucket = []
title_bucket_special = []
class BrowseMeh:
def export_default():
# For defaulting to the max allowed size
export_image_format = ExportBucket.default_export_bucket[0]
# get the hash (simple MD5 is fine for now)
formatter_export_string = md5()
delimiter_for_file = BROWSEMEH_TITLE.__getitem__("text").rsplit('.', 1)
# The delimiter has to be saved in caps (memory storage)
print(delimiter_for_file)
MemoryDelimiterNeeded = delimiter_for_file[-1].upper()
if MemoryDelimiterNeeded == 'JPG':
MemoryDelimiterNeeded = str('JPEG')
else:
MemoryDelimiterNeeded = str(MemoryDelimiterNeeded)
with BytesIO() as InMemStorage:
try:
export_image_format.save(InMemStorage, MemoryDelimiterNeeded)
hashed_media_data = InMemStorage.getvalue()
formatter_export_string.update(hashed_media_data)
except:
KeyError
print("No photo selected or the photo index is currently empty.")
# print(ACTIVE_MANIPULATOR.manipulator_bucket[0])
# For defaulting to the original size
# export_image_format = ACTIVE_MANIPULATOR.manipulator_bucket[0]
default_export_location = "IDENTITY/PHOTO/media/"
default_added_signature = formatter_export_string.hexdigest()
current_title_to_save = BROWSEMEH_TITLE.__getitem__("text")
try:
export_image_format.save(
default_export_location+delimiter_for_file[0]+"_"+
default_added_signature+"."+delimiter_for_file[1]
)
GENERAL_Status_Alert.configure(text="Export: default location")
print(
"Exporting the image to the default location: "+ default_export_location+\
current_title_to_save
)
except:
ValueError
GENERAL_Status_Alert.configure(text="Export: None selected")
print("Generate the required slug by using an allowed BrowseMeh Key.")
def window_height_logic(ImageBeta):
"""
Get the height based off of the frame height
"""
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.configure(text=\
"x "+STRING_WIDTH_ORIGINAL+"H")
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
if float(HEIGHT_ORIGINAL / max_height) < 1:
if resized_image_width(ImageBeta) < BROWSEMEH_MAX_WIDTH:
return(float(HEIGHT_ORIGINAL))
else:
return(int(float(HEIGHT_ORIGINAL/3)))
else:
if resized_image_width(ImageBeta) > BROWSEMEH_MAX_WIDTH:
return(int(float(max_height/3)))
else:
return(int(max_height))
def resized_image_width(ImageBeta):
HEIGHT_ORIGINAL = ImageBeta.size[1]
WIDTH_ORIGINAL = ImageBeta.size[0]
STRING_HEIGHT_ORIGINAL = str(HEIGHT_ORIGINAL)
STRING_WIDTH_ORIGINAL = str(WIDTH_ORIGINAL)
ORIGIN_AREA = HEIGHT_ORIGINAL*WIDTH_ORIGINAL
BROWSEMEH_ORIGINAL_SIZE_HEIGHT.configure(text=\
"x "+STRING_WIDTH_ORIGINAL+"W")
"""
Scale the width to meet the formatting provided by the frame height
"""
height = window_height_logic(ImageBeta)
h_percentage = float(height) / float(HEIGHT_ORIGINAL)
w_size = float(WIDTH_ORIGINAL) * float(h_percentage)
if int(w_size) > BROWSEMEH_MAX_WIDTH:
print("IMAGE TOO WIDE")
return(int(float(w_size)))
else:
return(int(w_size))
def window_height_logic_alpha(ImageAlpha):
"""
Get the height based off of the frame height
"""
# Dynamic
# return(BROWSEMEH.winfo_reqheight())
if (float(ImageAlpha.size[1]) / max_height) < 1:
if resized_image_width(ImageAlpha) < BROWSEMEH_MAX_WIDTH:
print("returned normal")
return(float(ImageAlpha.size[1]))
else:
return(int(float(ImageAlpha.size[1]/3)))
print("returned limited.")
else:
if resized_image_width(ImageAlpha) > BROWSEMEH_MAX_WIDTH:
return(int(float(max_height/3)))
print("returned a fat one and a tall one")
else:
return(int(max_height))
print("this one is just wide.")
def resized_image_width_alpha(ImageAlpha):
"""
Scale the width to meet the formatting provided by the frame height
"""
height = window_height_logic_alpha(ImageAlpha)
h_percentage = float(height) / float(ImageAlpha.size[1])
w_size = float(ImageAlpha.size[0]) * float(h_percentage)
if int(w_size) > BROWSEMEH_MAX_WIDTH:
print("IMAGE TOO WIDE")
return(int(w_size)/3)
else:
return(int(w_size))
try:
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((
BrowseMeh.resized_image_width_alpha(ImageAlpha),
BrowseMeh.window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
Alpha_PhotoImage = ImageTk.PhotoImage(ImageSized)
except:
FileNotFoundError
print("No Slug Loaded: Someone removed the image... Or... it's not here.")
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((
resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
Alpha_PhotoImage = ImageTk.PhotoImage(ImageSized)
AcceptedFileTypes = [
'*.gif', '*.GIF',
'*.jpg', '*.JPG',
'*.jpeg', '*.JPEG',
'*.png', '*.PNG',
'*.tif', '*.TIF'
]
def path_finder_special(PATH_SPECIAL_OPERATOR):
ListboxTitles.delete(0, ITL.END)
for i in title_bucket_special:
# entry_now = i.rsplit('/', 1)[-1]
ListboxTitles.insert(ITL.END, i)
try:
# without a value error, photos were found
title_bucket_special[0]
#***********************************************************#
# START: ACTION - #
# [Regular: BrowseMeh.ShowImage: load image] #
#***********************************************************#
print(
"---------- START: ACTION -" \
" [Regular: BrowseMeh.path_finder_special: load image] -----------"
)
FILE_COUNTER_FOR_INDEX = len(title_bucket_special)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="0 / "+STRING_INDEX_USED)
BrowseMeh.path_finder_special__LOGGER = "[Regular: BrowseMeh.ShowImage: "
BrowseMeh.path_finder_special__helper = "load image] "
BrowseMeh.path_finder_special__values = "[PathImage: "+ImageName+"] "
print(BrowseMeh.path_finder_special__LOGGER+BrowseMeh.path_finder_special__helper+\
ACTION_REGULAR(variable=BrowseMeh.path_finder_special__LOGGER+\
BrowseMeh.path_finder_special__helper+\
BrowseMeh.path_finder_special__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: BrowseMeh.path_finder_special: load image] -----------"
)
#***********************************************************#
# STOP: ACTION - #
# [Regular: BrowseMeh.ImageShow: load image] #
#***********************************************************#
except:
# with a ValueError, no photos were found - indicating a bad dir
# therefor, we remove the Counter text
ValueError
FILE_COUNTER_FOR_INDEX = len(title_bucket_special)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="Try another LLB")
#***********************************************************#
# START: Failure #
# [BROWSEMEH__path_finder_special__LOGGER: set link] #
#***********************************************************#
BROWSEMEH_path_finder_special__LOGGER = \
"[BROWSEMEH__path_finder_special__LOGGER: "
BROWSEMEH_path_finder_special__helper = "set link]"
print(BROWSEMEH_path_finder_special__LOGGER+\
BROWSEMEH_path_finder_special__helper+\
ALERT_LOGGING_FAILURE(
variable=BROWSEMEH_path_finder_special__LOGGER+\
BROWSEMEH_path_finder_special__helper)+\
"\n"
)
#***********************************************************#
# STOP: Failure #
# [BROWSEMEH__path_finder_special__LOGGER: set link] #
#***********************************************************#
BROWSEMEH_TITLE.configure(text=" ")
ListboxTitles.select_clear(0, ITL.END)
ListboxTitles.selection_anchor(1)
Cursor_N_position = ListboxTitles.curselection()
print("NEW CALLED PATH: SLUG FOR THIS PATH")
ImageName_auto = ListboxTitles.index(0)
ImageName = browsemeh_title_path+ListboxTitles.get(ImageName_auto)
try:
print("Checking IMAGE_SLUG_OPTION: "+\
IMAGE_SLUG_OPTION.manipulator_new_slug[0]
)
ImageAlpha = Image.open(ImageName)
ImageMB = float(getsize(
ImageName
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
print("ACTIVE MANIPULATOR STORE: A: "+str(ImageAlpha))
if IMAGE_SLUG_OPTION.manipulator_new_slug[0] == "NO SLUG":
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
FILE_COUNTER_FOR_INDEX = len(title_bucket_special)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="0 / "+STRING_INDEX_USED)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
else:
ImageRotated = IMAGE_SLUG_OPTION.manipulator_new_slug[0]
ACTIVE_MANIPULATOR.clear()
ImageAlpha = ImageRotated
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
print("ACTIVE MANIPULATOR STORE: B: "+\
str(ImageRotated)
)
IMAGE_SLUG_OPTION.manipulator_new_slug.clear()
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
FILE_COUNTER_FOR_INDEX = len(title_bucket_special)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="0 / "+STRING_INDEX_USED)
ImageSized = ImageAlpha.resize((
resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImageLabelBeta.i
except:
FileNotFoundError
BROWSEMEH_COUNTER.configure(text="Folder Not Found")
print("Someone removed the image... Or... it's not here.")
ImageMB = float(getsize(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
file_input_mechanism = []
def path_finder(browsemeh_title_path):
title_bucket.clear()
if browsemeh_title_path == BM.SLUG_BROWSEMEH:
new_path = BM.SLUG_BROWSEMEH
print("Case A")
else:
new_path = browsemeh_title_path
LabelBeta.config(image=None)
LabelBeta.image = None
print("Case B")
title_bucket.append(new_path)
curred_path = new_path
#.rsplit('file://', 1)[0]
for file_accepted in BrowseMeh.AcceptedFileTypes:
BrowseMeh.file_input_mechanism.extend(glob(curred_path+file_accepted))
BrowseMeh.file_input_mechanism.sort()
ListboxTitles.delete(0, ITL.END)
for PhotoImage in BrowseMeh.file_input_mechanism:
ListboxTitles.insert(ITL.END, PhotoImage.rsplit('/', 1)[-1])
try:
# without a value error, photos were found
BrowseMeh.file_input_mechanism[0]
#***********************************************************#
# START: ACTION - #
# [Regular: BrowseMeh.ShowImage: load image] #
#***********************************************************#
FILE_COUNTER_FOR_INDEX = len(BrowseMeh.file_input_mechanism)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="0 / "+STRING_INDEX_USED)
BrowseMeh.path_finder__LOGGER = "[Regular: BrowseMeh.ShowImage: "
BrowseMeh.path_finder__helper = "load image] "
BrowseMeh.path_finder__values = "[PathImage: "+ImageName+"] "
print(BrowseMeh.path_finder__LOGGER+BrowseMeh.path_finder__helper+\
ACTION_REGULAR(variable=BrowseMeh.path_finder__LOGGER+\
BrowseMeh.path_finder__helper+\
BrowseMeh.path_finder__values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: BrowseMeh.path_finder: load image] -----------"
)
#***********************************************************#
# STOP: ACTION - #
# [Regular: BrowseMeh.ImageShow: load image] #
#***********************************************************#
except:
# with a ValueError, no photos were found - indicating a bad dir
# therefor, we remove the Counter text
ValueError
FILE_COUNTER_FOR_INDEX = len(BrowseMeh.file_input_mechanism)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="Try another folder")
#***********************************************************#
# START: Failure #
# [BROWSEMEH__path_finder_LOGGER: set link] #
#***********************************************************#
BROWSEMEH_path_finder__LOGGER = "[BROWSEMEH__path_finder_LOGGER: "
BROWSEMEH_path_finder__helper = "set link]"
print(BROWSEMEH_path_finder__LOGGER+BROWSEMEH_path_finder__helper+\
ALERT_LOGGING_FAILURE(
variable=BROWSEMEH_path_finder__LOGGER+\
BROWSEMEH_path_finder__helper)+\
"\n"
)
#***********************************************************#
# STOP: Failure #
# [BROWSEMEH__path_finder_LOGGER: set link] #
#***********************************************************#
BROWSEMEH_TITLE.configure(text=" ")
ListboxTitles.select_clear(0, ITL.END)
ListboxTitles.selection_anchor(1)
Cursor_N_position = ListboxTitles.curselection()
print("NEW CALLED PATH: "+browsemeh_title_path)
ImageName_auto = ListboxTitles.index(0)
ImageName = browsemeh_title_path+ListboxTitles.get(ImageName_auto)
try:
print("Checking IMAGE_SLUG_OPTION: C Case"+\
IMAGE_SLUG_OPTION.manipulator_new_slug[0]
)
ImageMB = float(getsize(
ImageName
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
ImageAlpha = Image.open(ImageName)
if IMAGE_SLUG_OPTION.manipulator_new_slug[0] == "NO SLUG":
ACTIVE_MANIPULATOR.clear()
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
print("ACTIVE MANIPULATOR STORE: C:"+str(ImageAlpha))
FILE_COUNTER_FOR_INDEX = len(BrowseMeh.file_input_mechanism)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
BROWSEMEH_COUNTER.configure(text="0 / "+STRING_INDEX_USED)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
else:
ImageRotated = IMAGE_SLUG_OPTION.manipulator_new_slug[0]
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ImageAlpha = ImageRotated
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageAlpha)
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
print("ACTIVE MANIPULATOR STORE: D:"+\
str(ImageRotated)
)
IMAGE_SLUG_OPTION.manipulator_new_slug.clear()
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
except:
FileNotFoundError
BROWSEMEH_COUNTER.configure(text="Folder Not Found")
print("Someone removed the image... Or... it's not here.")
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
def ImageShow(event):
#def RESEED_LABEL_BETA():
# LabelBeta.destroy()
# LabelBeta = ITL.Label(BROWSEMEH_BOX)
# LabelBeta.pack(side="left")
#RESEED_LABEL_BETA()
Cursor_N_position = ListboxTitles.curselection()
#***********************************************************#
# START: ACTION - #
# [Regular: BrowseMeh.ImageShow: load image] #
#***********************************************************#
print(
"---------- START: ACTION -" \
" [Regular: BrowseMeh.ImageShow: load image] ----------"
)
if len(title_bucket_special) > 0:
ImageName = ListboxTitles.get(Cursor_N_position)
try:
ImageMB = float(getsize(
ImageName
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
FILE_COUNTER_FOR_INDEX = len(title_bucket_special)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
STRING_INDEX_CURRENT = title_bucket_special.index(ImageName)
INSERT_CURRENT = STRING_INDEX_CURRENT+1
CURRENT_SLUG = str(INSERT_CURRENT)
BROWSEMEH_COUNTER.configure(
text=CURRENT_SLUG+" / "+STRING_INDEX_USED
)
try:
print("CALLED PATH: "+title_bucket_special[INSERT_CURRENT])
#if title_bucket_special[INSERT_CURRENT].startswith('/'):
ExtractFileName = title_bucket_special[INSERT_CURRENT].rsplit('/', 1)[-1]
BROWSEMEH_TITLE.configure(text=ExtractFileName)
#else:
#BROWSEMEH_TITLE.configure(text=title_bucket_special[INSERT_CURRENT])
print(ImageName)
BrowseMeh.ImageShow_LOGGER = "[Regular: BrowseMeh.ShowImage: "
BrowseMeh.ImageShow_helper = "load image] "
BrowseMeh.ImageShow_values = "[PathImage: "+ImageName+"] "
print(BrowseMeh.ImageShow_LOGGER+BrowseMeh.ImageShow_helper+\
ACTION_REGULAR(variable=BrowseMeh.ImageShow_LOGGER+\
BrowseMeh.ImageShow_helper+\
BrowseMeh.ImageShow_values)+\
"\n")
print(
"---------- STOP: ACTION -" \
" [Regular: BrowseMeh.ImageShow: load image] -----------"
)
#***********************************************************#
# STOP: ACTION - #
# [Regular: BrowseMeh.ImageShow: load image] #
#***********************************************************#
except:
IndexError
print("It's possible that the "+KEY_LLB_PLAIN+" was reseeded.")
except:
FileNotFoundError
print("It's possible the file or folder has been moved or deleted.")
else:
try:
print("CALLED PATH: "+title_bucket[0])
except:
IndexError
print("Try it again now.")
try:
ImageName = title_bucket[0]+ListboxTitles.get(Cursor_N_position)
ImageMB = float(getsize(
ImageName
))/float(1024*1024)
ImageMB_Cured = float("{:.2f}".format(ImageMB))
ACTIVE_BASE_BYTES.base_byte_value_bucket.clear()
ACTIVE_BASE_BYTES.base_byte_value_bucket.append(ImageMB_Cured)
ImageMB_Slug = str(ImageMB_Cured)
BROWSEMEH_ORIGINAL_SIZE_THEN.configure(text=" / "+ImageMB_Slug+" MB")
FILE_COUNTER_FOR_INDEX = len(BrowseMeh.file_input_mechanism)
STRING_INDEX_USED = str(FILE_COUNTER_FOR_INDEX)
STRING_INDEX_CURRENT = BrowseMeh.file_input_mechanism.index(ImageName)
INSERT_CURRENT = STRING_INDEX_CURRENT+1
CURRENT_SLUG = str(INSERT_CURRENT)
BROWSEMEH_COUNTER.configure(
text=CURRENT_SLUG+" / "+STRING_INDEX_USED
)
#if ImageName.startswith('/'):
ExtractFileName = ImageName.rsplit('/', 1)[-1]
BROWSEMEH_TITLE.configure(text=ExtractFileName)
#else:
#BROWSEMEH_TITLE.configure(text=ImageName)
print(ImageName)
BrowseMeh.ImageShow_LOGGER = "[Regular: BrowseMeh.ShowImage: "
BrowseMeh.ImageShow_helper = "load image] "
BrowseMeh.ImageShow_values = "[PathImage: "+ImageName+"] "
print(BrowseMeh.ImageShow_LOGGER+BrowseMeh.ImageShow_helper+\
ACTION_REGULAR(variable=BrowseMeh.ImageShow_LOGGER+\
BrowseMeh.ImageShow_helper+\
BrowseMeh.ImageShow_values)+\
"\n")
except:
from tkinter import _tkinter
_tkinter.TclError
print("The directory was recently reseeded... proceeding: Done...")
print(
"---------- STOP: ACTION -" \
" [Regular: BrowseMeh.ImageShow: load image] -----------"
)
#***********************************************************#
# STOP: ACTION - #
# [Regular: BrowseMeh.ImageShow: load image] #
#***********************************************************#
# Always default hide ENTITY_COMPOUND on each CASE: E run
ENTITY_COMPOUND.place(x=-1000, y=-1000)
ENTITY_COMPOUND.update()
try:
ImageAlpha = Image.open(ImageName)
print("Checking IMAGE_SLUG_OPTION: Case E: "+\
IMAGE_SLUG_OPTION.manipulator_new_slug[0]
)
if IMAGE_SLUG_OPTION.manipulator_new_slug[0] == "NO SLUG":
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
print("ACTIVE MANIPULATOR STORE: E:"+str(ImageAlpha))
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
if str(type(ImageAlpha)) == "":
print("Case Detected: Special Sequential Image Data, Gif")
Main.state_checker.clear()
ImageSized = ACTIVE_MANIPULATOR.manipulator_bucket[0]
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
SPECIAL_OBJECT_IMAGE = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=SPECIAL_OBJECT_IMAGE)
LabelBeta.image = SPECIAL_OBJECT_IMAGE
ENTITY_COMPOUND.place(x=2400, y=200)
ENTITY_COMPOUND.update()
Main.FRAME_ZERO_BUCKET.clear()
Main.FRAME_EFN_BUCKET.clear()
Main.FRAME_IMAGE_NAME_BUCKET.clear()
Main.FRAME_ZERO_BUCKET.append(ImageSized)
Main.FRAME_EFN_BUCKET.append(ExtractFileName)
Main.FRAME_IMAGE_NAME_BUCKET.append(ImageName)
MACRO.gif_macro(
ImageSized,
ExtractFileName,
ImageName
)
else:
print("Case Detected: Regular Image")
ENTITY_COMPOUND.place(x=-1000, y=-1000)
ENTITY_COMPOUND.update()
PhotoImage = ImageTk.PhotoImage(ImageSized)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
MB_MULTIPLIER = ACTIVE_BASE_BYTES.base_byte_value_bucket[0]
MB_RATIO = COMPRESSION.compression_ratio_bucket[0]
print(MB_MULTIPLIER)
print(MB_RATIO)
if MB_MULTIPLIER == None:
MB_MULTIPLIER_Cured = 1
else:
MB_MULTIPLIER_Cured = MB_MULTIPLIER
MB_NOW = MB_RATIO*MB_MULTIPLIER
print("MB NOW :"+str(MB_NOW))
MB_NOW_Cured = float("{:.2f}".format(MB_NOW))
MB_NEEDED = str(MB_NOW_Cured)
BROWSEMEH_ORIGINAL_SIZE_NOW.configure(text=MB_NEEDED+" MB")
else:
ImageRotated = IMAGE_SLUG_OPTION.manipulator_new_slug[0]
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ImageAlpha = ImageRotated
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
print("ACTIVE MANIPULATOR STORE: F:"+\
str(ImageRotated)
)
IMAGE_SLUG_OPTION.manipulator_new_slug.clear()
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
except:
FileNotFoundError
BROWSEMEH_COUNTER.configure(text="The File has moved")
print("Someone removed the image... Or... it's not here.")
ENTITY_COMPOUND.place(x=-1000, y=-1000)
ENTITY_COMPOUND.update()
ImageAlpha = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
def finalize_retrieval(event):
BrowseMeh.ImageShow(event)
def ImageShowDefault(event):
# BrowseMeh.path_finder(browsemeh_title_path)
Cursor_N_position = ListboxTitles.curselection()
ImageName = ListboxTitles.get(Cursor_N_position)
ImageBeta = Image.open(
BM.SLUG_BROWSEMEH_DEFAULT+BM.BROWSEMEH_DEFAULT
)
ImageSized = ImageBeta.resize((resized_image_width(ImageBeta),
window_height_logic(ImageBeta)),
Image.ANTIALIAS
)
ExportBucket.default_export_bucket.clear()
ExportBucket.default_export_bucket.append(ImageSized)
PhotoImage = ImageTk.PhotoImage(ImageSized)
# CURED_PHOTO = browsemeh_title_path.PhotoImage
# PhotoImage = CURED_PHOTO
try:
# Fail if the list if empty, causing the default except ValueError fallback
BrowseMeh.file_input_mechanism.index(0)
except ValueError:
BROWSEMEH_COUNTER.configure(text="No Image Loaded: Default")
print("Collection Located... Are you ready?.")
ListboxTitles.bind("<>",
BrowseMeh.finalize_retrieval
)
def reseed(browsemeh_title_path):
LabelBeta.config(image=None)
LabelBeta.image = None
BrowseMeh.path_finder(browsemeh_title_path)
# This is always cleared because it serves as a counter for regular/LLB gallery attributes
title_bucket_special.clear()
def reseed_special_LLB(browsemeh_LLB_path):
LabelBeta.config(image=None)
LabelBeta.image = None
title_bucket_special.clear()
with open(SLUG_LLB_COMPACT+browsemeh_LLB_path+DASH_UTIL+LLBES, 'r') \
as LLB_reseed_values:
for line in LLB_reseed_values:
if line.startswith(KEY_LLB):
line = line.rsplit(KEY_LLB)[1]
cure_line_break = line.rstrip('\n')
title_bucket_special.append(cure_line_break)
else:
pass
# Create a PATH: SPECIAL_OPERATOR method
PATH_SPECIAL_OPERATOR = browsemeh_LLB_path
BrowseMeh.path_finder_special(PATH_SPECIAL_OPERATOR)
#def reseed_special_PK(browsemeh_PK_path):
# LabelBeta.config(image=None)
# LabelBeta.image = None
# title_bucket_special.clear()
# with open(CONTROL_FOLDER_VISUAL+browsemeh_PK_path, 'r') \
# as PK_reseed_values:
# for line in PK_reseed_values:
# if line.startswith(KEY_PK):
# line = line.rsplit(KEY_PK)[1]
# cure_line_break = line.rstrip('\n')
# title_bucket_special.append(cure_line_break)
# else:
# print("Incorrectly formatted Key: PK")
# PATH_SPECIAL_OPERATOR = browsemeh_PK_path
# BrowseMeh.path_finder_special(PATH_SPECIAL_OPERATOR)
def get_directory(event=None):
# Display the active path
browsemeh_title_path = BROWSEMEH_SEARCH_ENTRY.get()
# Add BrowseMeh Key functions here
if browsemeh_title_path.startswith(KEY_LLB_PLAIN):
print(KEY_LLB+" LLB SLUG DETECTED")
print(KEY_LLB_PLAIN+" LLB SET TO: "+browsemeh_title_path)
browsemeh_LLB_path = browsemeh_title_path
print('Starting multidemensional path finding... done.')
BrowseMeh.reseed_special_LLB(browsemeh_LLB_path)
GENERAL_Status_Alert.configure(text="SPECIAL SLUG: detected")
elif browsemeh_title_path.startswith(KEY_PK_PLAIN):
print(KEY_PK_PLAIN+" PK SLUG DETECTED")
print(KEY_PK_PLAIN+" PK SET TO: "+browsemeh_title_path)
BrowseMeh.file_input_mechanism.clear()
print("Altering Control Folder to the Visual Directory: "+CONTROL_FOLDER_VISUAL_VAULT+DASH_UTIL)
browsemeh_title_path = CONTROL_FOLDER_VISUAL_VAULT+browsemeh_title_path+DASH_UTIL
print('Starting multidemensional path finding... done.')
BrowseMeh.reseed(browsemeh_title_path)
GENERAL_Status_Alert.configure(text="SPECIAL SLUG: Visual detected")
else:
print('Current Browsemeh Directory: '+str(browsemeh_title_path))
BrowseMeh.file_input_mechanism.clear()
BrowseMeh.reseed(browsemeh_title_path)
GENERAL_Status_Alert.configure(text="")
def restore_default(event=None):
# Display the active path
BROWSEMEH_SEARCH_ENTRY.delete(0,
ITL.END
)
NEW_SLUG = BM.SLUG_BROWSEMEH_DEFAULT
BROWSEMEH_SEARCH_ENTRY.insert(ITL.INSERT,
NEW_SLUG
)
browsemeh_title_path = BROWSEMEH_SEARCH_ENTRY.get()
print('Current Browsemeh Directory: '+str(browsemeh_title_path))
BrowseMeh.file_input_mechanism.clear()
BrowseMeh.reseed(browsemeh_title_path)
GENERAL_Status_Alert.configure(text="Defaults restored")
class BrowseMehUtility:
def space(event=None):
ListboxTitles.curselection()
# ListboxTitles.selection_set()
ListboxTitles.bind("<>",
BrowseMeh.finalize_retrieval
)
ListboxTitles.bind("",
BrowseMehUtility.space
)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
BROWSEMEH_SEARCH_ENTRY.insert(0,
browsemeh_title_path
)
BROWSEMEH_NAVIGATOR_OPEN = ttk.Button(BROWSEMEH,
text="OPEN",
command=BrowseMeh.get_directory
)
BROWSEMEH_NAVIGATOR_OPEN.place(x=2150, y=12)
BROWSEMEH_SEARCH_ENTRY.bind('',
BrowseMeh.get_directory
)
BROWSEMEH_NAVIGATOR_DEFAULT = ttk.Button(BROWSEMEH,
text="Reset",
command=BrowseMeh.restore_default
)
BROWSEMEH_NAVIGATOR_DEFAULT.place(x=2350, y=15)
BROWSEMEH_EXPORT_DEFAULT = ttk.Button(BROWSEMEH,
text="Export",
command=BrowseMeh.export_default
)
BROWSEMEH_EXPORT_DEFAULT.place(x=2550, y=15)
LLB_BrowseMeh_SCROLLER_COLLECTION = scrolledtext.ScrolledText(
BROWSEMEH,
width=42, height=48,
wrap= ITL.WORD
)
LLB_BrowseMeh_SCROLLER_COLLECTION.place(x=2800, y=120)
LLB_BrowseMeh_CREATOR_FRAME = ITL.Frame(BROWSEMEH,
bg='Black',
width=710,
height=1200
)
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
LLB_BrowseMeh_CREATE_TITLE_ENTRY = ITL.Entry(LLB_BrowseMeh_CREATOR_FRAME,
borderwidth=16,
relief= ITL.FLAT
)
LLB_BrowseMeh_CREATE_TITLE_ENTRY.place(x=14, y=14)
LLB_BrowseMeh_CREATE_TITLE_ENTRY.configure()
LLB_BrowseMeh_SCROLLER_MAIN = scrolledtext.ScrolledText(
LLB_BrowseMeh_CREATOR_FRAME,
width=38, height=28,
wrap= ITL.WORD
)
LLB_BrowseMeh_SCROLLER_MAIN.place(x=18, y=180)
LLB_Status_Alert = ttk.Label(LLB_BrowseMeh_CREATOR_FRAME,
text=KEY_LLB+" Creator V.1")
LLB_Status_Alert.place(x=22, y=110)
# State 1: Disabled by default
ENTITY_BOOL_ENABLED_OVERWRITE_LLB = ITL.IntVar()
OPTION_ENABLE_OVERWRITE_LLB = ITL.Checkbutton(
LLB_BrowseMeh_CREATOR_FRAME,
text="Overwrite",
variable=ENTITY_BOOL_ENABLED_OVERWRITE_LLB,
state='normal'
)
OPTION_ENABLE_OVERWRITE_LLB.deselect()
OPTION_ENABLE_OVERWRITE_LLB.place(x=450, y=14)
GENERAL_Status_Alert = ttk.Label(BROWSEMEH,
text='')
GENERAL_Status_Alert.place(x=3200, y=14)
class LLB_BroseMeh_Edit:
LLB_edit_value = []
def LLB_edit():
LLB_BrowseMeh_CREATE_TITLE_ENTRY.delete(0, ITL.END)
EDIT_THIS_LLB = BROWSEMEH_SEARCH_ENTRY.get()
if EDIT_THIS_LLB.startswith(KEY_LLB_PLAIN):
REMOVEDLLB = EDIT_THIS_LLB.split(KEY_LLB_PLAIN)[1]
LLB_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
LLB_BrowseMeh_CREATE_TITLE_ENTRY.insert(0, REMOVEDLLB)
else:
print("You can't edit regular links yet")
GENERAL_Status_Alert.configure(text="You can't edit regular links")
try:
with open(SLUG_LLB_COMPACT+EDIT_THIS_LLB+DASH_UTIL+LLBES, 'r') as LLB_edit:
LLB_BroseMeh_Edit.LLB_edit_value.clear()
LLB_BroseMeh_Edit.LLB_edit_value.append(EDIT_THIS_LLB)
print("Read "+KEY_LLB_PLAIN+" Value: "+EDIT_THIS_LLB+DASH_UTIL+LLBES)
for line in LLB_edit:
if line.startswith(KEY_LLB):
LLB = line
print(line)
def get_b():
return(LLB)
LLB_BrowseMeh_SCROLLER_MAIN.insert(ITL.INSERT, get_b())
elif line.startswith("features: "):
features = line
curred_features = features.split("features: ")[1]
LLB_edit.close()
except:
FileNotFoundError
print("It's possible that you have to try an LLB not a directory")
##############################################################################
# The Basic convention carries these parts
# Status
# _create_LockerLink_BrowseMeh_Quality.is_active[0]=='ACTIVE
# Physical-frame
# LLBQ_BrowseMeh_CREATOR_FRAME
# Key based editing
# EDIT_THIS_LLBQ.startswith(KEY_LLBQ_PLAIN)
# Abort button
# Button_LockerLink_Create_BrowseMeh_Quality_abort
# Hide button
# Button_LockerLink_Create_BrowseMeh_Quality_hide
# Create button: Note, everything is a create, even an edit.
# - Override only
# Button_LockerLink_Create_BrowseMeh_Quality
#
# Each LockerLink: BrowseMeh condition will activate a schema
# for an interactive-box. Each box will take it's own methodology
# but will share some common elements, such as add/delete methods
###############################################################################
# When the LockerLink: BrowseMeh -> Qualitybox is activated
###############################################################################
#if _create_LockerLink_BrowseMeh_Quality.is_active[0]=='ACTIVE':
# LLBQ_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
# GENERAL_Status_Alert.configure(text="You're already creating qualitative descriptor.")
#else:
# if EDIT_THIS_LLBQ.startswith(KEY_LLBQ_PLAIN):
# GENERAL_Status_Alert.configure(text="Editing LLBQ.")
# _create_LockerLink_BrowseMeh_Quality.is_active.clear()
# _create_LockerLink_BrowseMeh_Quality.is_active.append('ACTIVE')
# print("LLBQ STATUS: ACTIVE")
# Button_LockerLink_Create_BrowseMeh_Quality_abort = ttk.Button(
# LLBQ_BrowseMeh_CREATOR_FRAME,
# text="Abort",
# command=_create_LockerLink_BrowseMeh_Quality.form_destroy
# )
# Button_LockerLink_Create_BrowseMeh_Quality_abort.place(x=12, y=1130)
# Button_LockerLink_Create_BrowseMeh_Quality_abort.configure()
#
# Button_LockerLink_Create_BrowseMeh_Quality_hide = ttk.Button(
# LLBQ_BrowseMeh_CREATOR_FRAME,
# text="Hide",
# command=_create_LockerLink_BrowseMeh_Quality.form_hide
# )
# Button_LockerLink_Create_BrowseMeh_Quality_hide.place(x=212, y=1130)
# Button_LockerLink_Create_BrowseMeh_Quality_hide.configure()
#
# Button_LockerLink_Create_BrowseMeh_Quality = ttk.Button(
# LLBQ_BrowseMeh_CREATOR_FRAME,
# text=KEY_LLBQ+" Create",
# command=LLBQ_BrowseMeh_Creator.submit_LLBQ_BrowseMeh
# )
# Button_LockerLink_Create_BrowseMeh_Quality.place(x=412, y=1130)
# Button_LockerLink_Create_BrowseMeh_Quality.configure()
# else:
# print("You can't create a quality of that type.")
# GENERAL_Status_Alert.configure(text="You can't create a quality of that type.")
#######################################################################
# When the LockerLink: BrowseMeh box -> Default is activated
#######################################################################
if _create_LockerLink_BrowseMeh.is_active[0]=='ACTIVE':
LLB_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
GENERAL_Status_Alert.configure(text="You're already creating another LLB.")
else:
if EDIT_THIS_LLB.startswith(KEY_LLB_PLAIN):
GENERAL_Status_Alert.configure(text="Editing LLB.")
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append('ACTIVE')
print("LLB STATUS: ACTIVE")
Button_LockerLink_Create_BrowseMeh_abort = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text="Abort",
command=_create_LockerLink_BrowseMeh.form_destroy
)
Button_LockerLink_Create_BrowseMeh_abort.place(x=12, y=1130)
Button_LockerLink_Create_BrowseMeh_abort.configure()
Button_LockerLink_Create_BrowseMeh_hide = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text="Hide",
command=_create_LockerLink_BrowseMeh.form_hide
)
Button_LockerLink_Create_BrowseMeh_hide.place(x=212, y=1130)
Button_LockerLink_Create_BrowseMeh_hide.configure()
Button_LockerLink_Create_BrowseMeh = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text=KEY_LLB+" Create",
command=LLB_BrowseMeh_Creator.submit_LLB_BrowseMeh
)
Button_LockerLink_Create_BrowseMeh.place(x=412, y=1130)
Button_LockerLink_Create_BrowseMeh.configure()
else:
print("You can't edit regular links yet")
GENERAL_Status_Alert.configure(text="You can't edit regular links")
# Each interfactive box within BrowseMeh will get its own class
# That means it'll have it's own 'Destroy' context, i.e a defined
# add and delete formula depending on what the interactive-box
# intent is.
#class LLB_BrowseMeh_Quality_Destroy:
#
# def LLB_destroy():
# DESTROY_THIS_LLBQ = BROWSEMEH_SEARCH_ENTRY.get()
# from core_creator import LockerLink_BrowseMeh
# if LockerLink_BrowseMeh.LLB_destroy(DESTROY_THIS_LLB) == \
# "Nothing was found...":
# GENERAL_Status_Alert.configure(text="Delete: None selected")
# else:
# print("Destroyed LLB SLUG: "+DESTROY_THIS_LLB)
# GENERAL_Status_Alert.configure(text="The Slug was terminated.")
# ListboxTitles.delete(0, ITL.END)
# BROWSEMEH_SEARCH_ENTRY.delete(0, ITL.END)
# LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
# SLUG_LLB_COMPACT
# )
class LLB_BrowseMeh_Destroy:
def LLB_destroy():
DESTROY_THIS_LLB = BROWSEMEH_SEARCH_ENTRY.get()
from core_creator import LockerLink_BrowseMeh
if LockerLink_BrowseMeh.LLB_destroy(DESTROY_THIS_LLB) == \
"Nothing was found...":
GENERAL_Status_Alert.configure(text="Delete: None selected")
else:
print("Destroyed LLB SLUG: "+DESTROY_THIS_LLB)
GENERAL_Status_Alert.configure(text="The Slug was terminated.")
ListboxTitles.delete(0, ITL.END)
BROWSEMEH_SEARCH_ENTRY.delete(0, ITL.END)
LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
SLUG_LLB_COMPACT
)
BUTTON_GENERAL_Edit_LLB = ttk.Button(BROWSEMEH,
text='E',
command=LLB_BroseMeh_Edit.LLB_edit
)
BUTTON_GENERAL_Edit_LLB.place(x=2800, y=1767)
BUTTON_GENERAL_Delete_LLB = ttk.Button(BROWSEMEH,
text='X',
command=LLB_BrowseMeh_Destroy.LLB_destroy
)
BUTTON_GENERAL_Delete_LLB.place(x=3000, y=1767)
class ROTATE_IMAGE:
def ROTATE_COUNTER_CLOCKWISE():
try:
rotate_this_image = ACTIVE_MANIPULATOR.manipulator_bucket[0]
rotate_angle = 90
IMAGE_SLUG = rotate_this_image.rotate(rotate_angle, expand=True)
IMAGE_SLUG_OPTION.manipulator_new_slug.clear()
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
# IMAGE_SLUG_OPTION.manipulator_new_slug.append("TEST")
print("Rotated Image Returned: "+\
str(IMAGE_SLUG_OPTION.manipulator_new_slug[0])
)
ImageAlpha = IMAGE_SLUG
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
print("Image roated 90 degrees counter clockwise")
except:
IndexError
GENERAL_Status_Alert.configure(text="No photo was selected.")
print("No photo was selected.")
def ROTATE_CLOCKWISE():
try:
rotate_this_image = ACTIVE_MANIPULATOR.manipulator_bucket[0]
rotate_angle = -90
IMAGE_SLUG = rotate_this_image.rotate(rotate_angle, expand=True)
IMAGE_SLUG_OPTION.manipulator_new_slug.clear()
IMAGE_SLUG_OPTION.manipulator_new_slug.append("NO SLUG")
#IMAGE_SLUG_OPTION.manipulator_new_slug.append("TEST 2")
print("Rotated Image Returned: "+\
str(IMAGE_SLUG_OPTION.manipulator_new_slug[0])
)
ImageAlpha = IMAGE_SLUG
ACTIVE_MANIPULATOR.manipulator_bucket.clear()
ACTIVE_MANIPULATOR.manipulator_bucket.append(ImageAlpha)
ImageSized = ImageAlpha.resize((resized_image_width_alpha(ImageAlpha),
window_height_logic_alpha(ImageAlpha)),
Image.ANTIALIAS
)
PhotoImage = ImageTk.PhotoImage(ImageSized)
LabelBeta.config(image=PhotoImage)
LabelBeta.image = PhotoImage
print("Image roated 90 degrees clockwise")
except:
IndexError
GENERAL_Status_Alert.configure(text="No photo was selected.")
print("No photo was selected.")
BUTTON_GENERAL_CC = ttk.Button(BROWSEMEH,
text='90 CC',
command=ROTATE_IMAGE.ROTATE_COUNTER_CLOCKWISE
)
BUTTON_GENERAL_CC.place(x=3200, y=1767)
BUTTON_GENERAL_C = ttk.Button(BROWSEMEH,
text='90 C',
command=ROTATE_IMAGE.ROTATE_CLOCKWISE
)
BUTTON_GENERAL_C.place(x=3400, y=1767)
class LLB_BrowseMeh_Creator:
"""
Create lists of pictures to run as a
LLB:/path/to/LLB_BrowseMeh/folder/
All values in the title bar proceeded by LL: will read the full path
into the list box.
This allows for currated lists from folders adhering to the IPDVS
date/time format.
"""
def make_LLB_BrowseMeh_Slug(event=None):
# take from path source bar.
path_LLB_BrowseMeh = BROWSEMEH_SEARCH_ENTRY.get()
GENERAL_Status_Alert.configure(text="")
# take from the current img name slug
ImageEpsilonSource = BROWSEMEH_TITLE['text']
if _create_LockerLink_BrowseMeh.is_active[0]=='ACTIVE':
# LockerLink: BrowseMeh
SLUG_LLB_BrowseMeh = KEY_LLB+path_LLB_BrowseMeh+ImageEpsilonSource+'\n'
LLB_BrowseMeh_SCROLLER_MAIN.insert(ITL.INSERT, SLUG_LLB_BrowseMeh)
LLB_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
else:
BROWSEMEH_TITLE.configure(text='Alert: LockerLink must be active: Cannot add - '+BROWSEMEH_TITLE['text'])
print('Alert: LLB must be active')
def submit_LLB_BrowseMeh(event=None):
DESTROY_THIS_LLB_TREE = KEY_LLB_PLAIN+LLB_BrowseMeh_CREATE_TITLE_ENTRY.get()
# First check to see if overwrite is selected in case of a conflict
STRING_ENTITY_BOOL_ENABLED_OVERWRITE_LLB = \
str(ENTITY_BOOL_ENABLED_OVERWRITE_LLB.get())
print("Checking Overwrite Status for: "+ \
STRING_ENTITY_BOOL_ENABLED_OVERWRITE_LLB
)
if ENTITY_BOOL_ENABLED_OVERWRITE_LLB.get() == 1:
# delete the old LLB
from core_creator import LockerLink_BrowseMeh
NEW_LLB_TITLE = LLB_BrowseMeh_CREATE_TITLE_ENTRY.get()
LLB_path_writer = []
z = LLB_BrowseMeh_SCROLLER_MAIN.get(1.0, ITL.END)
LLB_path_writer.append(z)
SLUG_LLB_BrowseMeh = LLB_path_writer[0]
if LockerLink_BrowseMeh.LLB_treeswap(DESTROY_THIS_LLB_TREE,
NEW_LLB_TITLE,
SLUG_LLB_BrowseMeh
) == \
"Nothing was found to SWAP/overwrite...":
GENERAL_Status_Alert.configure(text="Created: No SWAP/overwrite.")
# Perform the standard routine. A LockerLink is created after the null destroy
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append("NOT_ACTIVE")
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
OPTION_ENABLE_OVERWRITE_LLB.deselect()
LLB_BrowseMeh_CREATE_TITLE_ENTRY.delete(0, ITL.END)
LLB_BrowseMeh_SCROLLER_MAIN.delete("1.0", ITL.END)
LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
SLUG_LLB_COMPACT
)
else:
print("SWAP/OVERWRITE: Okay")
GENERAL_Status_Alert.configure(text="SWAP/OVERWRITE: Okay")
# Perform the standard routine. A LockerLink is created after the null destroy
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append("NOT_ACTIVE")
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
OPTION_ENABLE_OVERWRITE_LLB.deselect()
LLB_BrowseMeh_CREATE_TITLE_ENTRY.delete(0, ITL.END)
LLB_BrowseMeh_SCROLLER_MAIN.delete("1.0", ITL.END)
LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
SLUG_LLB_COMPACT
)
else:
# When the LockerLink is created, it will destroy this
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append("NOT_ACTIVE")
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
NEW_LLB_TITLE = LLB_BrowseMeh_CREATE_TITLE_ENTRY.get()
LLB_path_writer = []
z = LLB_BrowseMeh_SCROLLER_MAIN.get(1.0, ITL.END)
LLB_path_writer.append(z)
SLUG_LLB_BrowseMeh = LLB_path_writer[0]
from core_creator import LockerLink_BrowseMeh
if LockerLink_BrowseMeh.create_LockerLink_BrowseMeh(NEW_LLB_TITLE,
SLUG_LLB_BrowseMeh) == "Directory Exists":
print("Try again...")
LLB_Status_Alert.configure(text='Name Existed... Try again.')
GENERAL_Status_Alert.configure(text='Name exists... Try again.')
else:
LLB_BrowseMeh_SCROLLER_MAIN.delete("1.0", ITL.END)
LLB_BrowseMeh_CREATE_TITLE_ENTRY.delete(0, ITL.END)
LLB_Status_Alert.configure(text='LLB: Creator V.1')
GENERAL_Status_Alert.configure(text='LLB Created')
OPTION_ENABLE_OVERWRITE_LLB.deselect()
LLB_BrowseMeh_CREATE_TITLE_ENTRY.delete(0, ITL.END)
LLB_BrowseMeh_SCROLLER_MAIN.delete("1.0", ITL.END)
LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
SLUG_LLB_COMPACT
)
ListboxTitles.bind('',
LLB_BrowseMeh_Creator.make_LLB_BrowseMeh_Slug
)
class _create_LockerLink_BrowseMeh:
"""
Create the pop up and navigate through the LockerLink
control logic
"""
# add "ACTIVE" to the
is_active = []
def form_assemble():
GENERAL_Status_Alert.configure(text="New Collection")
# When the LockerLink: BrowseMeh box is activated
if _create_LockerLink_BrowseMeh.is_active[0]=='ACTIVE':
LLB_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
else:
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append('ACTIVE')
print(KEY_LLB_PLAIN+" STATUS: ACTIVE")
LLB_BrowseMeh_CREATOR_FRAME.place(x=2800, y=130)
LLB_BrowseMeh_CREATOR_FRAME.configure()
Button_LockerLink_Create_BrowseMeh_abort = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text="Abort",
command=_create_LockerLink_BrowseMeh.form_destroy
)
Button_LockerLink_Create_BrowseMeh_abort.place(x=12, y=1130)
Button_LockerLink_Create_BrowseMeh_abort.configure()
Button_LockerLink_Create_BrowseMeh_hide = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text="Hide",
command=_create_LockerLink_BrowseMeh.form_hide
)
Button_LockerLink_Create_BrowseMeh_hide.place(x=212, y=1130)
Button_LockerLink_Create_BrowseMeh_hide.configure()
Button_LockerLink_Create_BrowseMeh = ttk.Button(
LLB_BrowseMeh_CREATOR_FRAME,
text="LLB: Create",
command=LLB_BrowseMeh_Creator.submit_LLB_BrowseMeh
)
Button_LockerLink_Create_BrowseMeh.place(x=412, y=1130)
Button_LockerLink_Create_BrowseMeh.configure()
def form_hide():
# When the LockerLink is hiden, it will remain active
# Nothing happens
GENERAL_Status_Alert.configure(text="LLB Creator Hidden")
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
def form_destroy():
# When the LockerLink is created, it will destroy this
_create_LockerLink_BrowseMeh.is_active.clear()
_create_LockerLink_BrowseMeh.is_active.append("NOT_ACTIVE")
GENERAL_Status_Alert.configure(text="Aborted LLB Creation")
print("LLB STATUS: NOT_ACTIVE")
LLB_BrowseMeh_SCROLLER_MAIN.delete("1.0", ITL.END)
LLB_BrowseMeh_CREATOR_FRAME.place(x=-1000, y=-1000)
_create_LockerLink_BrowseMeh.is_active.append('NOT_ACTIVE')
BROWSEMEH_NAVIGATOR_LOCKERLINK = ttk.Button(BROWSEMEH,
text="LockerLink: BrowseMeh",
command=_create_LockerLink_BrowseMeh.form_assemble
)
BROWSEMEH_NAVIGATOR_LOCKERLINK.place(x=2800, y=15)
print(
"---------- STOP: INSTANCE 6 - BROWSEMEH ----------\n"
)
#**********************************************************#
# STOP: INSTANCE 6 - BROWSEMEH #
#**********************************************************#
###########################################################################
# Feedbox Overview: Lockerlink, Chat, Media
###########################################################################
ENTITY_SCROLLER_LL_MAIN = scrolledtext.ScrolledText(
ENTITY_OVERVIEW,
width=36, height=6,
wrap= ITL.WORD
)
ENTITY_SCROLLER_LL_MAIN.place(x=14, y=1600)
def ACCESS_BOOKMARKS():
PARSED_LIST_BOOKMARKS = []
PARSED_LIST_BOOKMARKS_NO = []
def get_BOOKMARKS():
# InspectMachinePackages.inspect_packages()
# core_operations.get_information_CORE_PACKAGES()
with open(SLUG_LOCKERLINKS_STORAGE_DS, 'r') as f:
PARSED_LIST_BOOKMARKS.append("Bookmarks: Clean \n")
for row in f:
PARSED_LIST_BOOKMARKS.append(row)
PARSED_LIST_BOOKMARKS.append("-" * 79 +"\n")
f.close()
return(PARSED_LIST_BOOKMARKS[:])
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT,
get_BOOKMARKS()
)
# LOGGER
get_BOOKMARKS_LOGGER = "[get_BOOKMARKS_LOGGER: "
get_BOOKMARKS_helper = "open file]"
print(get_BOOKMARKS_LOGGER+get_BOOKMARKS_helper+\
ALERT_LOGGING_WARNING(variable=get_BOOKMARKS_LOGGER+get_BOOKMARKS_helper)+"\n")
#def get_OVERVIEW_AUDIO():
#print("GETTING THE AUDIO OVERVIEW...")
#ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
#ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "# Overview: Audio")
#with open('DATA/log.es', 'r') as f:
# for row in f:
# LOG_LIST.append(row)
# f.close()
# LOG_LIST.reverse()
# ENTITY_SCROLLER_EMULATOR.insert(ITL.INSERT, LOG_LIST)
def get_OVERVIEW_VISUAL():
print("Generating Smart Visual Mapping...")
if getsize(DIRDATA+RINGVISUAL) == 0:
with open(DIRDATA+RINGVISUAL, 'r') as TRY_FOR_POPULATED:
for row in TRY_FOR_POPULATED:
print("FIRST ROW CHECK: "+row)
# MAPPING SLUG: PERSON to VISUAL
print("None Detected... Generating New Visual Map now")
print(row)
TRY_FOR_POPULATED.close()
print("GETTING THE VISUAL OVERVIEW...")
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "# Overview: Visual")
import re
# Sequence Alpha
list_row_value = []
list_visual_slug = []
list_to_seek_with_contact = []
list_matched_master = []
linker_slug = 'DS2000001.linker'
with open(ENTITY_HUMAN_PERSON_DATASHEET+\
XLX+DASH_UTIL+CONTACT_SLUG_LINKER, "r") as linker:
for row in linker:
matcher = re.findall(r'(?<=\")\w+', row)
# print(matcher)
list_row_value.append(matcher)
# print(list_row_value[0])
list_visual_slug.append(list_row_value[0])
list_row_value.clear()
for i in list_visual_slug[1:]:
try:
list_to_seek_with_contact.append((i[0], i[2], i[4]))
print("<<>>: "+str(linker_slug)+\
" <<>>: "+i[0]+\
" <<>>: "+i[2]+\
" <<>>: "+i[4]
)
except:
IndexError
print("NO MATCH: Continuing...")
fillloc_bucket = []
key_directory = {}
for i in list_to_seek_with_contact:
fillds = str(i[2])
print(fillds)
fillloc = str(i[1])
print(fillloc)
fillcode = str(i[0])
print(fillcode)
fillloc_bucket.append(fillloc)
key_insert = {fillloc: fillcode}
key_directory.update(key_insert)
count_row = 1
# This box has to link the two files
CONSTRUCTED_SLUG = ENTITY_HUMAN_PERSON_DATASHEET+fillds+ext_ds
print(CONSTRUCTED_SLUG)
with open( CONSTRUCTED_SLUG, 'r') as CONTACT_MASTER:
# print("---------- "+fillcode+" : "+fillds+" ----------")
# print(row)
for row in CONTACT_MASTER:
# any(i in fillloc_bucket for i in fillloc_bucket)
pattern = re.compile('|'.join(fillloc_bucket))
result = pattern.search(row)
try:
result_key = result.group()
print(row)
print("LOOKING WITH: "+str(pattern)+"->> "+str(result))
if result is not None:
print("Row: "+str(count_row)+" - "+"Bingo")
code_inserted = key_directory.get(result_key)
# print(core_inserted)
list_matched_master.append(code_inserted+": "+row)
count_row += 1
else:
pass
count_row += 1
except:
AttributeError
count_row += 1
print("Row: "+str(count_row)+" - No match found in this row")
CONTACT_MASTER.close()
for i in list_matched_master:
print(i)
print("MATCHED MASTER CONTACT: extend...")
with open(DIRDATA+RINGVISUAL, 'w') as VISUAL:
for i in list_matched_master:
VISUAL.write('%s\n' % i)
print("VISUAL RELATIONSHIP DATA WRITTEN")
VISUAL.close()
def add_box():
return(list_matched_master[:])
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, add_box())
print("DONE MATCHING")
linker.close()
else:
print("PREVIOUS MAPPINGS DETECTED...")
previous_mappings = []
def add_box():
with open(DIRDATA+RINGVISUAL, 'r') as VISUAL:
for row in VISUAL:
previous_mappings.append(row)
print("VISUAL RELATIONSHIP DATA WRITTEN: "+row)
VISUAL.close()
add_box()
def run_box():
previous_mappings.sort()
return(previous_mappings[:])
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "# Overview: Visual")
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, run_box())
previous_mappings.clear()
print("DONE")
class OVERVIEW_TYPE:
def ACCESS_OPENPACKAGER():
PARSED_LIST_OPENPACKAGER = []
def get_ACTIVE_PACKAGES():
# InspectMachinePackages.inspect_packages()
# core_operations.get_information_CORE_PACKAGES()
with open(DIRDATA+PACKAGES, 'r') as f:
PARSED_LIST_OPENPACKAGER.append(
"Virtual Environment Packages: External \n"
)
for row in f:
PARSED_LIST_OPENPACKAGER.append(row)
PARSED_LIST_OPENPACKAGER.append("-" * 79 +"\n")
f.close()
PARSED_LIST_OPENPACKAGER.append("System Programs: External \n")
PARSED_LIST_OPENPACKAGER.append("EventLolli \n")
PARSED_LIST_OPENPACKAGER.append("BrowseMeh \n")
PARSED_LIST_OPENPACKAGER.append("RemindMe \n")
PARSED_LIST_OPENPACKAGER.append("OpenPackager \n")
return(PARSED_LIST_OPENPACKAGER[:])
ENTITY_SCROLLER_EMULATOR.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END,
get_ACTIVE_PACKAGES()
)
# LOGGER
get_ACTIVE_PACKAGES__LOGGER = "[get_ACTIVE_PACKAGES__LOGGER: "
get_ACTIVE_PACKAGES__helper = "open file]"
print(get_ACTIVE_PACKAGES__LOGGER+get_ACTIVE_PACKAGES__helper+\
ALERT_LOGGING_WARNING(variable=get_ACTIVE_PACKAGES__LOGGER+\
get_ACTIVE_PACKAGES__helper)+"\n")
def ACCESS_COMMANDS():
ACCESS_COMMANDS = "CORE ACCESS COMMANDS\n"
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END,
ACCESS_COMMANDS
)
# LOGGER
get_COMMANDS_LOGGER = "[get_COMMANDS_LOGGER: "
get_COMMANDS_helper = "open file]"
print(get_COMMANDS_LOGGER+get_COMMANDS_helper+\
ALERT_LOGGING_WARNING(variable=get_COMMANDS_LOGGER+get_COMMANDS_helper)+"\n")
def ACCESS_BRANCHES():
ACCESS_BRANCHES = "CORE ACCESS BRANCHES\n"
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END,
ACCESS_BRANCHES
)
# LOGGER
get_BRANCHES_LOGGER = "[get_BRANCHES_LOGGER: "
get_BRANCHES_helper = "open file]"
print(get_BRANCHES_LOGGER+get_BRANCHES_helper+\
ALERT_LOGGING_WARNING(variable=get_BRANCHES_LOGGER+get_BRANCHES_helper)+"\n")
def get_OVERVIEW_ELEMENTS():
print("GETTING THE ELEMENTS OVERVIEW...")
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "# Overview: Elements\n")
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 1: OpenPackager\n")
OVERVIEW_TYPE.ACCESS_OPENPACKAGER()
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 2: Branches\n")
OVERVIEW_TYPE.ACCESS_BRANCHES()
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 3: Commands\n")
OVERVIEW_TYPE.ACCESS_COMMANDS()
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 4: XYZ Objects\n")
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "None defined...\n")
def get_OVERVIEW_FILES():
print("GETTING THE FILES OVERVIEW...")
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "# Overview: Files\n")
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 1: Documents\n")
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.END, "# PART 2: Figments\n")
def ACCESS_ORE():
PARSED_LIST_ORE = []
def get_ORE():
with open(DIRDATA+SLUG_ORE_LEDGER, 'r') as f:
PARSED_LIST_ORE.append("ORE Parsed: \n")
for row in f:
PARSED_LIST_ORE.append(row)
PARSED_LIST_ORE.append("-" * 79 +"\n")
f.close()
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0, ITL.END)
ENTITY_OVERVIEW_ENTERED.delete(0, ITL.END)
return(PARSED_LIST_ORE[:])
ENTITY_SCROLLER_ADD_ITEM_MAIN.delete(1.0,
ITL.END
)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT,
get_ORE()
)
# LOGGER
get_ORE_LOGGER = "[get_ORE_LOGGER: "
get_ORE_helper = "open file]"
print(get_ORE_LOGGER+get_ORE_helper+\
ALERT_LOGGING_WARNING(variable=get_ORE_LOGGER+get_ORE_helper)+"\n")
# ORE
ENTITY_AUDIO = ttk.Button(ENTITY_OVERVIEW,
text="ORE", command=ACCESS_ORE
)
ENTITY_AUDIO.place(x=2600, y=1450)
ENTITY_AUDIO = ttk.Button(ENTITY_OVERVIEW,
text="LockerLinks", command=ACCESS_BOOKMARKS
)
ENTITY_AUDIO.place(x=2800, y=1750)
ENTITY_VISUAL = ttk.Button(ENTITY_OVERVIEW,
text="VISUAL", command=get_OVERVIEW_VISUAL
)
ENTITY_VISUAL.place(x=3000, y=1750)
ENTITY_ELEMENTS = ttk.Button(ENTITY_OVERVIEW,
text="ELEMENTS", command=get_OVERVIEW_ELEMENTS
)
ENTITY_ELEMENTS.place(x=3200, y=1750)
ENTITY_FILES = ttk.Button(ENTITY_OVERVIEW,
text="FILES", command=get_OVERVIEW_FILES
)
ENTITY_FILES.place(x=3400, y=1750)
#**********************************************************#
# START: INSTANCE 7 - BUILD LOCKERLINKS #
#**********************************************************#
print(
"---------- START: INSTANCE 7 - BUILD LOCKERLINKS ----------\n"
)
LL_bucket = []
class LL_ARCHIVE:
object = '.es'
AcceptedFileTypes = ["**/*"+object]
file_input_mechanism = []
LL_temp_holder = []
def path_finder_LL(LL_title_path):
for file_accepted in LL_ARCHIVE.AcceptedFileTypes:
GO = LL_title_path+file_accepted
print(GO)
LL_ARCHIVE.file_input_mechanism.extend(glob(GO,
recursive=True
))
for i in LL_ARCHIVE.file_input_mechanism:
print(i)
LL_ARCHIVE.file_input_mechanism.sort()
for LL in LL_ARCHIVE.file_input_mechanism:
LL_ARCHIVE.LL_temp_holder.append(LL)
print(KEY_LL+" "+LL)
LL_bucket.clear()
for i in LL_ARCHIVE.LL_temp_holder:
with open(i, 'r') as LL_open:
for line in LL_open:
if line.startswith(KEY_TITLE):
LL_TITLE=line
elif line.startswith(KEY_DIRECTORY):
LL_DIRECTORY=line
else:
pass
LL_bucket.append(LL_TITLE+" : "+LL_DIRECTORY+'\n')
LL_open.close()
# Make sure this is cleared before reseeding the info box
ENTITY_SCROLLER_LL_MAIN.delete("1.0", ITL.END)
for i in LL_bucket:
print(i)
ENTITY_SCROLLER_LL_MAIN.insert(ITL.END, i)
LL_ARCHIVE.file_input_mechanism.clear()
LL_ARCHIVE.LL_temp_holder.clear()
LL_bucket.clear()
LL_ARCHIVE.path_finder_LL(LL_title_path= \
SLUG_LL_COMPACT
)
print(
"---------- STOP: INSTANCE 7 - BUILD LOCKERLINKS ----------\n"
)
#**********************************************************#
# STOP: INSTANCE 7 - BUILD LOCKERLINKS #
#**********************************************************#
ENTITY_SCROLLER_OVERVIEW_MAIN = scrolledtext.ScrolledText(
ENTITY_OVERVIEW,
width=120, height=36,
wrap= ITL.WORD
)
ENTITY_SCROLLER_OVERVIEW_MAIN.place(x=680, y=14)
ENTITY_SCROLLER_ADD_ITEM_MAIN = scrolledtext.ScrolledText(
ENTITY_OVERVIEW,
width=50, height=40,
wrap= ITL.WORD
)
ENTITY_SCROLLER_ADD_ITEM_MAIN.place(x=2800, y=204)
ENTITY_SCROLLER_ADD_ITEM_MAIN.insert(ITL.INSERT, "FOLDER EXPLORER")
ENTITY_SCROLLER_OVERVIEW_OUT = scrolledtext.ScrolledText(
ENTITY_OVERVIEW,
width=102, height=6,
borderwidth=10,
relief= ITL.SUNKEN,
wrap= ITL.WORD
)
ENTITY_SCROLLER_OVERVIEW_OUT.place(x=800, y=1300)
class COMM_STATE:
COMMUNICATE_STATE = 0
bucket_STREAM = []
def ADD_ALL():
print("ADD ALL: NOW")
bucket_STREAM.append("BUCKET: ADD ALL")
return(bucket_STREAM[0])
#def ADD_ENTITIES():
# print("ADD ENTITIES: NOW")
# bucket_STREAM.append("BUCKET: ADD ENTITIES")
#return(bucket_STREAM[0])
#def ADD_ORE():
# print("ADD ORE: NOW")
#bucket_STREAM.append("BUCKET: ADD ORE")
# return(bucket_STREAM[0])
#def ADD_BOOKMARKS():
#print("ADD BOOKMARKS: NOW")
#bucket_STREAM.append("BUCKET: ADD BOOKMARKS")
#return(bucket_STREAM[0])
#def ADD_FIGMENTS():
# print("ADD FIGMENTS: NOW")
# bucket_STREAM.append("BUCKET: ADD FIGMENTS")
# return(bucket_STREAM[0])
#def ADD_DOCUMENTS():
#print("ADD DOCUMENTS: NOW")
#bucket_STREAM.append("BUCKET: ADD DOCUMENTS")
#return(bucket_STREAM[0])
#def ADD_PHOTOS():
# print("ADD PHOTOS: NOW")
# bucket_STREAM.append("BUCKET: ADD PHOTOS")
# return(bucket_STREAM[0])
#def ADD_MUSIC():
# print("ADD MUSIC: NOW")
# bucket_STREAM.append("BUCKET: ADD MUSIC")
# return(bucket_STREAM[0])
#def ADD_COMMANDS():
# print("ADD COMMANDS: NOW")
# bucket_STREAM.append("BUCKET: ADD COMMANDS")
# return(bucket_STREAM[0])
#def ADD_BRANCHES():
# print("ADD BRANCHES: NOW")
# bucket_STREAM.append("BUCKET: ADD BRANCHES")
# return(bucket_STREAM[0])
#def ADD_OPENPACKAGER():
# print("ADD OPENPACKAGER: NOW")
# bucket_STREAM.append("BUCKET: ADD OPENPACKAGER")
# return(bucket_STREAM[0])
# def ADD_CONTACT_BUSINESS():
# print("ADD CONTACT BUSINESS: NOW")
# bucket_STREAM.append("BUCKET: ADD CONTACT BUSINESS")
#return(bucket_STREAM[0])
#def ADD_CONTACT_INDEX():
#print("ADD CONTACT INDEX: NOW")
# bucket_STREAM.append("BUCKET: ADD CONTACT INDEX")
#return(bucket_STREAM[0])
# def ADD_EVENT_GAME_EVENTLOLLI():
# print("ADD EVENT GAME: EVENTLOLLI->: NOW")
# bucket_STREAM.append("BUCKET: ADD EVEMT GAME: EVENTLOLLI->: NOW")
# return(bucket_STREAM[0])
class COMMUNICATE:
def STREAM_TYPE(event):
if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'ALL':
ADD_ALL()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'ENTITIES':
#ADD_ENTITIES()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'ORE':
# ADD_ORE()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'BOOKMARKS':
# ADD_BOOKMARKS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'FIGMENTS':
# ADD_FIGMENTS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'DOCUMENTS':
# ADD_DOCUMENTS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'PHOTOS':
# ADD_PHOTOS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'MUSIC':
# ADD_MUSIC()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'COMMANDS':
# ADD_COMMANDS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'BRANCHES':
# ADD_BRANCHES()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'OPENPACKAGER':
# ADD_OPENPACKAGER()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'CONTACT: Business':
# ADD_CONTACT_BUSINESS()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'CONTACT: Index':
# ADD_CONTACT_INDEX()
#if ENTITY_SELECTOR_FIGMENT_STREAM_TAG.get() == 'EVENT:GAME:EVENTLOLLI':
# ADD_EVENT_GAME_EVENTLOLLI()
def STREAM_data(event):
bucket_STREAM.clear()
COMMUNICATE.STREAM_TYPE(event)
def connect(event=None):
import socket
import sys
new_comm = ""
HOST, PORT = SLUG_HOST_PERSONAL, int(PORTCONNECT_TO)
# Sanity tests if you're having problems finding ports/hosts
print("HOST: ", HOST)
print("PORT: ", PORT)
if COMM_STATE.COMMUNICATE_STATE == 0:
data = default_Welcome
# data = " ".join(sys.argv[1:])
else:
data_pre = ENTITY_SCROLLER_OVERVIEW_OUT.get("1.0",
ITL.END
)
try:
stream_now = str(bucket_STREAM[0])
ENTITY_SCROLLER_OVERVIEW_OUT.focus()
data = default_add(default=data_pre, figment_stream=stream_now)
except:
IndexError
ENTITY_SCROLLER_OVERVIEW_OUT.focus()
data = default_add(default=data_pre, figment_stream="BUCKET: ADD ALL")
#**********************************************************#
# START: INSTANCE 8 - ALLOCATE THREAD #
#**********************************************************#
print(
"---------- START: INSTANCE 8 - ALLOCATE THREAD ----------\n"
)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
try:
sock.connect((HOST, PORT))
sock.sendall(bytes(data + "\n", encoding_connect_in))
print("Sent: {}".format(data))
# LOGGER
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER = \
"[STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER: "
STANDARD_HANDLER_TCP_REQUEST__handle__helper = \
"Received: thread outbound]"
print(STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper)
ALERT_LOGGING_INFO(variable=\
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper+"\n")
try:
received = str(sock.recv(1024), encoding_connect_in)
except:
UnboundLocalError
print("no connection built, skipping...")
except:
ConnectionRefusedError
print("Connection Error: Check sever status... failing back.")
try:
print("Received: {}".format(received))
# LOGGER
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER = \
"[STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER: "
STANDARD_HANDLER_TCP_REQUEST__handle__helper = \
"Received: thread inbound]"
print(STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper)
ALERT_LOGGING_INFO(variable=\
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper+"\n")
except:
UnboundLocalError
print("Received: empty")
# LOGGER
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER = \
"[STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER: "
STANDARD_HANDLER_TCP_REQUEST__handle__helper = \
"Received: thread empty]"
print(STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper)
ALERT_LOGGING_INFO(variable=\
STANDARD_HANDLER_TCP_REQUEST__handle__LOGGER+\
STANDARD_HANDLER_TCP_REQUEST__handle__helper+"\n")
try:
ENTITY_SCROLLER_OVERVIEW_MAIN.insert(ITL.INSERT, received)
COMM_STATE.COMMUNICATE_STATE += 1
except:
UnboundLocalError
print("Try starting the server.")
print(
"---------- STOP: INSTANCE 8 - ALLOCATE THREAD ----------\n"
)
#**********************************************************#
# STOP: INSTANCE 8 - ALLOCATE THREAD #
#**********************************************************#
ENTITY_SCROLLER_OVERVIEW_OUT.delete("1.0",
ITL.END
)
ENTITY_SELECTOR_FIGMENT_STREAM_TAG = ITL.StringVar()
ENTITY_SELECTOR_FIGMENT_STREAM_TAG = ttk.Combobox(ENTITY_OVERVIEW,
width=18,
textvariable=ENTITY_SELECTOR_FIGMENT_STREAM_TAG,
state='readonly'
)
ENTITY_SELECTOR_FIGMENT_STREAM_TAG['values'] = (
"ALL",
)
#ENTITY_SELECTOR_FIGMENT_STREAM_TAG['values'] = (
# "ALL", "ENTITIES", "ORE", "BOOKMARKS", "FIGMENTS",
# "DOCUMENTS", "PHOTOS", "MUSIC", "COMMANDS",
# "BRANCHES", "OPENPACKAGER",
# "CONTACT: Business", "CONTACT: Index", "EVENT:GAME:EVENTLOLLI"
#)
ENTITY_SELECTOR_FIGMENT_STREAM_TAG.place(x=2230, y=1520)
ENTITY_SELECTOR_FIGMENT_STREAM_TAG.bind("<>",
COMMUNICATE.STREAM_data
)
ENTITY_SELECTOR_FIGMENT_STREAM_TAG.current(0)
ENTITY_SCROLLER_OVERVIEW_OUT.bind('',
COMMUNICATE.connect
)
COMMUNICATE.connect(event=None)
CORE_OVERVIEW_SEND_BUTTON = ttk.Button(ENTITY_OVERVIEW,
text="SEND", command=COMMUNICATE.connect)
CORE_OVERVIEW_SEND_BUTTON.place(x=2600, y=1350)
#ENTITY_SCROLLER_OVERVIEW_OUT.bind('',
# COMMUNICATE.connect)
###########################################################################
# Frame OVERVIEW OPERATOR: System MemberPhoto
###########################################################################
OverviewOperatorImage = Image.open(
SLUG_OPERATOR+DEFAULT_OPERATOR_PHOTO
)
OperatorImageSized = OverviewOperatorImage.resize((377, 377),
Image.ANTIALIAS)
OperatorPhoto = ImageTk.PhotoImage(OperatorImageSized)
OVERVIEW_OPERATOR = ITL.Frame(ENTITY_OVERVIEW)
OVERVIEW_OPERATOR.place(x=8, y=8)
LabelOverviewOperator = ITL.Label(OVERVIEW_OPERATOR,
text=GLOBAL_MEMBER)
LabelOverviewOperator.pack(side="left")
LabelOverviewOperator.config(image=OperatorPhoto)
LabelOverviewOperator.image = OperatorPhoto
LabelOperatorName = ttk.Label(OVERVIEW_OPERATOR,
text=GLOBAL_MEMBER)
LabelOperatorName.place(x=8, y=330)
OperatorImageBadge = Image.open(gatekeeper_photo)
OperatorImageBadgeSized = OperatorImageBadge.resize((89, 89),
Image.ANTIALIAS
)
OperatorImageBadgePhoto = ImageTk.PhotoImage(OperatorImageBadgeSized)
OVERVIEW_OPERATOR_BADGE = ITL.Frame(ENTITY_OVERVIEW)
OVERVIEW_OPERATOR_BADGE.place(x=280, y=430)
LabelOverviewOperatorBadge = ITL.Label(OVERVIEW_OPERATOR_BADGE,
text=GLOBAL_MEMBER)
LabelOverviewOperatorBadge.pack(side="left")
LabelOverviewOperatorBadge.config(image=OperatorImageBadgePhoto)
LabelOverviewOperatorBadge.image = OperatorImageBadgePhoto
LabelOperatorBadge = ttk.Label(OVERVIEW_OPERATOR_BADGE)
LabelOperatorBadge.place(x=8, y=330)
###########################################################################
# Frame STATS Code
###########################################################################
STATS_FRAME = ITL.Frame(ENTITY_OVERVIEW,
bg='Black'
)
STATS_FRAME.place(x=410, y=8)
###########################################################################
# Init Sanity Tests (Substitute Globals to see if they're reading.
###########################################################################
class ENTITY_COUNTER:
def CORE_COUNT():
x = Ring.ENTITY.tally_core()
return(x)
def ENTITY_COUNT():
x = Ring.ENTITY.tally_entities()
return(x)
def FIGMENT_COUNT():
x = Ring.ENTITY.tally_figments()
return(x)
def SHOW_SIZE():
x = Ring.ENTITY.size()
return(x)
###########################################################################
from core_interface import SanityCheck
###########################################################################
SanityCheck.do()
################
# End and update stat labels upon change
################
buttons_FRONTEND_INTERFACE_STATS = ttk.LabelFrame(STATS_FRAME,
text='ENTITY STATS')
buttons_FRONTEND_INTERFACE_STATS.grid(column=0, row=0)
ttk.Label(buttons_FRONTEND_INTERFACE_STATS,
text='core.es: ').grid(column=0, row=0, sticky= ITL.W)
LabelCoreCount = ITL.Label(ENTITY_OVERVIEW,
text=ENTITY_COUNTER.CORE_COUNT())
LabelCoreCount.place(x=550, y=51)
ttk.Label(buttons_FRONTEND_INTERFACE_STATS,
text='Figment: ').grid(column=0, row=1, sticky= ITL.W)
LabelFigmentCount = ITL.Label(ENTITY_OVERVIEW,
text=ENTITY_COUNTER.FIGMENT_COUNT())
LabelFigmentCount.place(x=550, y=106)
ttk.Label(buttons_FRONTEND_INTERFACE_STATS,
text='Entities: ').grid(column=0, row=2, sticky= ITL.W)
LabelEntityCount = ITL.Label(ENTITY_OVERVIEW,
text=ENTITY_COUNTER.ENTITY_COUNT())
LabelEntityCount.place(x=550, y=161)
ttk.Label(buttons_FRONTEND_INTERFACE_STATS,
text='Size: ').grid(column=0, row=3, sticky= ITL.W)
LabelSizeCount = ITL.Label(ENTITY_OVERVIEW,
text=ENTITY_COUNTER.SHOW_SIZE())
LabelSizeCount.place(x=550, y=216)
def UPDATE_STATS():
z1 = ENTITY_COUNTER.CORE_COUNT()
print(z1)
LabelCoreCount.configure(text=z1)
z2 = ENTITY_COUNTER.FIGMENT_COUNT()
print(z2)
LabelFigmentCount.configure(text=z2)
z3 = ENTITY_COUNTER.ENTITY_COUNT()
print(z3)
LabelEntityCount.configure(text=z3)
z4 = ENTITY_COUNTER.SHOW_SIZE()
print(z4)
LabelSizeCount.configure(text=z4)
print("Updated Stats: All - Falling back")
# align Label overview vertically
for child in buttons_FRONTEND_INTERFACE_STATS.winfo_children():
child.grid_configure(padx=10, pady=10)
UPDATE_STATS = ttk.Button(ENTITY_OVERVIEW,
text="UPDATE STATS", command=UPDATE_STATS)
UPDATE_STATS.place(x=410, y=300)
#########################################################################
# LockerLinks: BrowseMeh
class _create_LockerLink:
"""
Create the pop up and navigate through the LockerLink
control logic
"""
LL_CREATOR_FRAME = ITL.Frame(ENTITY_OVERVIEW,
bg='Black',
width=620,
height=1000
)
LL_CREATOR_FRAME.place(x=-1000, y=-1000)
LL_CREATOR_FRAME.configure()
LL_CREATE_TITLE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL_CREATE_TITLE_ENTRY.place(x=10, y=10)
LL_CREATE_TITLE_ENTRY.configure()
LL1_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL1_CREATE_ENTRY.place(x=10, y=85)
LL1_CREATE_ENTRY.configure()
LL2_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL2_CREATE_ENTRY.place(x=10, y=160)
LL2_CREATE_ENTRY.configure()
LL3_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL3_CREATE_ENTRY.place(x=10, y=235)
LL3_CREATE_ENTRY.configure()
LL4_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL4_CREATE_ENTRY.place(x=10, y=310)
LL4_CREATE_ENTRY.configure()
LL5_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL5_CREATE_ENTRY.place(x=10, y=385)
LL5_CREATE_ENTRY.configure()
LL6_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL6_CREATE_ENTRY.place(x=10, y=460)
LL6_CREATE_ENTRY.configure()
LL7_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL7_CREATE_ENTRY.place(x=10, y=535)
LL7_CREATE_ENTRY.configure()
LL8_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL8_CREATE_ENTRY.place(x=10, y=610)
LL8_CREATE_ENTRY.configure()
LL9_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL9_CREATE_ENTRY.place(x=10, y=685)
LL9_CREATE_ENTRY.configure()
LL10_CREATE_ENTRY = ITL.Entry(LL_CREATOR_FRAME,
borderwidth=16,
font=('Courier', 12, 'bold'),
width=24,
relief= ITL.FLAT
)
LL10_CREATE_ENTRY.place(x=10, y=760)
LL10_CREATE_ENTRY.configure()
class edit_LockerLink:
edit_value = []
def get_values():
EDIT_VALUE = HEATER_SEARCH.get()
_create_LockerLink.LL_CREATOR_FRAME.place(x=800, y=800)
Button_LockerLink_Create.place(x=-1000, y=-1000)
Button_LockerLink_Create.configure()
Button_LockerLink_Edit = ttk.Button(_create_LockerLink.LL_CREATOR_FRAME,
text="LockerLink: Edit",
command=edit_LockerLink.set_values
)
Button_LockerLink_Edit.place(x=14, y=860)
Button_LockerLink_Edit.configure()
with open(SLUG_LL_COMPACT+EDIT_VALUE+DASH_UTIL+LLES, 'r') as LL_edit:
edit_LockerLink.edit_value.clear()
edit_LockerLink.edit_value.append(EDIT_VALUE)
print("Read LockerLink: "+EDIT_VALUE+DASH_UTIL+LLES)
for line in LL_edit:
if line.startswith(KEY_TITLE+" "):
LLTITLE = line
curred_LLTITLE = LLTITLE.split(KEY_TITLE+" ")[1]
a = curred_LLTITLE
print(a)
def get_a():
return(a)
_create_LockerLink.LL_CREATE_TITLE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL_CREATE_TITLE_ENTRY.insert(0, get_a())
elif line.startswith(KEY_LL1+" "):
LL1 = line
curred_LL1 = LL1.split(KEY_LL1+" ")[1]
b = curred_LL1
print(b)
def get_b():
return(b)
_create_LockerLink.LL1_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL1_CREATE_ENTRY.insert(0, get_b())
elif line.startswith(KEY_LL2+" "):
LL2 = line
curred_LL2 = LL2.split(KEY_LL2+" ")[1]
c = curred_LL2
print(c)
def get_c():
return(c)
_create_LockerLink.LL2_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL2_CREATE_ENTRY.insert(0, get_c())
elif line.startswith(KEY_LL3+" "):
LL3 = line
curred_LL3 = LL3.split(KEY_LL3+" ")[1]
d = curred_LL3
print(d)
def get_d():
return(d)
_create_LockerLink.LL3_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL3_CREATE_ENTRY.insert(0, get_d())
elif line.startswith(KEY_LL4+" "):
LL4 = line
curred_LL4 = LL4.split(KEY_LL4+" ")[1]
e = curred_LL4
print(e)
def get_e():
return(e)
_create_LockerLink.LL4_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL4_CREATE_ENTRY.insert(0, get_e())
elif line.startswith(KEY_LL5+" "):
LL5 = line
curred_LL5 = LL5.split(KEY_LL5+" ")[1]
f = curred_LL5
print(f)
def get_f():
return(f)
_create_LockerLink.LL5_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL5_CREATE_ENTRY.insert(0, get_f())
elif line.startswith(KEY_LL6+" "):
LL6 = line
curred_LL6 = LL6.split(KEY_LL6+" ")[1]
g = curred_LL6
print(g)
def get_g():
return(g)
_create_LockerLink.LL6_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL6_CREATE_ENTRY.insert(0, get_g())
elif line.startswith(KEY_LL7+" "):
LL7 = line
curred_LL7 = LL7.split(KEY_LL7+" ")[1]
h = curred_LL7
print(h)
def get_h():
return(h)
_create_LockerLink.LL7_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL7_CREATE_ENTRY.insert(0, get_h())
elif line.startswith(KEY_LL8+" "):
LL8 = line
curred_LL8 = LL8.split(KEY_LL8+" ")[1]
i = curred_LL8
print(i)
def get_i():
return(i)
_create_LockerLink.LL8_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL8_CREATE_ENTRY.insert(0, get_i())
elif line.startswith(KEY_LL9+" "):
LL9 = line
curred_LL9 = LL9.split(KEY_LL9+" ")[1]
j = curred_LL9
print(j)
def get_j():
return(j)
_create_LockerLink.LL9_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL9_CREATE_ENTRY.insert(0, get_j())
elif line.startswith(KEY_LL10+" "):
LL10 = line
curred_LL10 = LL10.split(KEY_LL10+" ")[1]
k = curred_LL10
print(k)
def get_k():
return(k)
_create_LockerLink.LL10_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL10_CREATE_ENTRY.insert(0, get_k())
elif line.startswith(KEY_FEATURES+" "):
features = line
curred_features = features.split(KEY_FEATURES+" ")[1]
def set_values():
SLUG_current_LockerLink = edit_LockerLink.edit_value[0]
_create_LockerLink.LL_CREATOR_FRAME.place(x=-1000, y=-1000)
a = _create_LockerLink.LL_CREATE_TITLE_ENTRY.get()
b = _create_LockerLink.LL1_CREATE_ENTRY.get()
c = _create_LockerLink.LL2_CREATE_ENTRY.get()
d = _create_LockerLink.LL3_CREATE_ENTRY.get()
e = _create_LockerLink.LL4_CREATE_ENTRY.get()
f = _create_LockerLink.LL5_CREATE_ENTRY.get()
g = _create_LockerLink.LL6_CREATE_ENTRY.get()
h = _create_LockerLink.LL7_CREATE_ENTRY.get()
i = _create_LockerLink.LL8_CREATE_ENTRY.get()
j = _create_LockerLink.LL9_CREATE_ENTRY.get()
k = _create_LockerLink.LL10_CREATE_ENTRY.get()
# delete the fields
_create_LockerLink.LL_CREATE_TITLE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL1_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL2_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL3_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL4_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL5_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL6_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL7_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL8_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL9_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL10_CREATE_ENTRY.delete(0, ITL.END)
Button_LockerLink_Create.place(x=330, y=860)
Button_LockerLink_Create.configure()
from core_creator import LockerLink
LockerLink.edit_LockerLink(a, b, c, d, e, f, g, h, i, j, k, SLUG_current_LockerLink)
print("---- Setting Current Link to: ----")
edit_LockerLink__get_values__LOGGER = "[edit_LockerLink__get_values__LOGGER: "
edit_LockerLink__get_values__helper = "set link]"
print(edit_LockerLink__get_values__LOGGER+edit_LockerLink__get_values__helper+\
ALERT_LOGGING_WARNING(variable=edit_LockerLink__get_values__LOGGER+\
edit_LockerLink__get_values__helper)+"\n")
class make_LockerLink:
def pull_LL_title():
z= _create_LockerLink.LL_CREATE_TITLE_ENTRY.get()
# print(z)
return(z)
def pull_LL1():
z = _create_LockerLink.LL1_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL2():
z = _create_LockerLink.LL2_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL3():
z = _create_LockerLink.LL3_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL4():
z = _create_LockerLink.LL4_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL5():
z = _create_LockerLink.LL5_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL6():
z = _create_LockerLink.LL6_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL7():
z = _create_LockerLink.LL7_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL8():
z = _create_LockerLink.LL8_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL9():
z = _create_LockerLink.LL9_CREATE_ENTRY.get()
# print(z)
return(z)
def pull_LL10():
z = _create_LockerLink.LL10_CREATE_ENTRY.get()
# print(z)
return(z)
def abort():
# clear the hooks
_create_LockerLink.LL_CREATOR_FRAME.place(x=-1000, y=-1000)
_create_LockerLink.LL_CREATE_TITLE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL1_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL2_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL3_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL4_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL5_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL6_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL7_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL8_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL9_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL10_CREATE_ENTRY.delete(0, ITL.END)
def pull_all_links():
a = make_LockerLink.pull_LL_title()
b = make_LockerLink.pull_LL1()
c = make_LockerLink.pull_LL2()
d = make_LockerLink.pull_LL3()
e = make_LockerLink.pull_LL4()
f = make_LockerLink.pull_LL5()
g = make_LockerLink.pull_LL6()
h = make_LockerLink.pull_LL7()
i = make_LockerLink.pull_LL8()
j = make_LockerLink.pull_LL9()
k = make_LockerLink.pull_LL10()
ENTITY_SCROLLER_LL_MAIN.delete("1.0", ITL.END)
from core_creator import LockerLink
LockerLink.create_LockerLink(a, b, c, d, e, f, g, h, i, j, k)
# update the LockerLink list
LL_ARCHIVE.path_finder_LL(LL_title_path= \
SLUG_LL_COMPACT
)
# clear the hooks
_create_LockerLink.LL_CREATOR_FRAME.place(x=-1000, y=-1000)
_create_LockerLink.LL_CREATE_TITLE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL1_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL2_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL3_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL4_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL5_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL6_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL7_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL8_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL9_CREATE_ENTRY.delete(0, ITL.END)
_create_LockerLink.LL10_CREATE_ENTRY.delete(0, ITL.END)
# update the LockerLink list
LL_ARCHIVE.path_finder_LL(LL_title_path= \
SLUG_LL_COMPACT
)
Button_LockerLink_Create = ttk.Button(_create_LockerLink.LL_CREATOR_FRAME,
text="LockerLink: Create",
command=make_LockerLink.pull_all_links
)
Button_LockerLink_Create.place(x=14, y=860)
Button_LockerLink_Create.configure()
Button_LockerLink_abort = ttk.Button(_create_LockerLink.LL_CREATOR_FRAME,
text="Abort",
command=make_LockerLink.abort
)
Button_LockerLink_abort.place(x=414, y=860)
Button_LockerLink_abort.configure()
def make_LL_frame():
_create_LockerLink.LL_CREATOR_FRAME.place(x=800, y=800)
_create_LockerLink.LL_CREATOR_FRAME.configure()
Button_LockerLink_Creator = ttk.Button(ENTITY_OVERVIEW,
text="Create New",
command=make_LL_frame
)
Button_LockerLink_Creator.place(x=400, y=400)
Button_LockerLink_Editor = ttk.Button(ENTITY_OVERVIEW,
text="E",
command=edit_LockerLink.get_values
)
Button_LockerLink_Editor.place(x=620, y=1340)
#**********************************************************#
# START: SPECIAL 1 - BUILD LOCKERLINKS BrowseMeh #
#**********************************************************#
print(
"---------- START: SPECIAL 1 - BUILD LOCKERLINKS BrowseMeh ----------\n"
)
print(CONTROL_FOLDER_MEMORY_VAULT)
print(FOLDER_MEMORY_VAULT_KEY)
print(CONTROL_FOLDER_ORE)
print(FOLDER_ORE_CONTROL_KEY)
print(CONTROL_FOLDER_VISUAL_VAULT)
print(FOLDER_VISUAL_CONTROL_KEY)
print(FOLDER_VISUAL_CONTROL_KEY_ALT)
print(FOLDER_VISUAL_CONTROL_KEY_SPECIAL)
print(CONTROL_FOLDER_VIDEOS)
print(FOLDER_VIDEOS_CONTROL_KEY)
print(CONTROL_FOLDER_AUDIO)
print(FOLDER_AUDIO_CONTROL_KEY)
LLB_bucket = []
LLB_bucket_QUALITY = []
LLB_bucket_TOKEN_ID = []
LLB_bucket_CATEGORY_SET_RANK = []
LLB_bucket_CATEGORY_SET_CHARACTER = []
class LLB_ARCHIVE:
object = ext_es
AcceptedFileTypes = ["**/*"+object]
# Control_Folder = ""
file_input_mechanism = []
LLB_temp_holder = []
def path_finder_LLB(LLB_title_path):
LLB_BrowseMeh_SCROLLER_COLLECTION.delete("1.0", ITL.END)
for file_accepted in LLB_ARCHIVE.AcceptedFileTypes:
GO = LLB_title_path+file_accepted
LLB_ARCHIVE.file_input_mechanism.extend(glob(GO,
recursive=True
))
for i in LLB_ARCHIVE.file_input_mechanism:
print('LockerLink: ')
print(i)
LLB_ARCHIVE.file_input_mechanism.sort()
for LLB in LLB_ARCHIVE.file_input_mechanism:
LLB_ARCHIVE.LLB_temp_holder.append(LLB)
print(KEY_LLB+" "+LLB)
for i in LLB_ARCHIVE.LLB_temp_holder:
LLB_bucket_QUALITY.clear()
LLB_bucket_TOKEN_ID.clear()
LLB_bucket_CATEGORY_SET_RANK.clear()
LLB_bucket_CATEGORY_SET_CHARACTER.clear()
with open(i, 'r') as LLB_open:
for line in LLB_open:
if line.startswith(KEY_TITLE):
LLB_TITLE=line
elif line.startswith(KEY_DIRECTORY):
LLB_DIRECTORY=line
elif line.startswith(KEY_QUALITY):
LLB_bucket_QUALITY.append(line)
elif line.startswith(KEY_TOKEN_ID):
LLB_bucket_TOKEN_ID.append(line)
elif line.startswith(KEY_CATEGORY_SET_RANK):
LLB_bucket_CATEGORY_SET_RANK.append(line)
elif line.startswith(KEY_CATEGORY_SET_CHARACTER):
LLB_bucket_CATEGORY_SET_CHARACTER.append(line)
else:
pass
LLB_bucket.append(LLB_TITLE+" : "+LLB_DIRECTORY)
print(LLB_bucket_QUALITY[0])
print(LLB_bucket_TOKEN_ID[0])
print(LLB_bucket_CATEGORY_SET_RANK[0])
print(LLB_bucket_CATEGORY_SET_CHARACTER[0])
# TOKEN_ID and QUALITY configs go here...
LLB_open.close()
for i in LLB_bucket:
LLB_BrowseMeh_SCROLLER_COLLECTION.insert(ITL.END, i)
LLB_BrowseMeh_SCROLLER_COLLECTION.configure()
LLB_bucket.clear()
LLB_ARCHIVE.LLB_temp_holder.clear()
LLB_ARCHIVE.file_input_mechanism.clear()
LLB_ARCHIVE.path_finder_LLB(LLB_title_path= \
SLUG_LLB_COMPACT
)
LLB_bucket.clear()
LLB_ARCHIVE.LLB_temp_holder.clear()
LLB_ARCHIVE.file_input_mechanism.clear()
print('LLB_bucket: Now')
print(LLB_bucket[:])
print('LLB_temp_holder: Now')
print(LLB_ARCHIVE.LLB_temp_holder[:])
print('LLB_ARCHIVE.file_input_mechanism: Now')
print(LLB_ARCHIVE.file_input_mechanism[:])
print(
"---------- STOP: SPECIAL 1 - BUILD LOCKERLINKS BrowseMeh ----------\n"
)
###########################################################################
# XY Interact Event Bindings - Frontend
###########################################################################
XYInteractEventBindings.create_event(ENTITY_SPINBOX_OVERVIEW_A,
"Scroll through the I/O numbers")
###########################################################################
# Construct the Frontend
###########################################################################
INTERFACE_CONTROLLER.pack(expand=1, fill="both")
# Finally, change the state
return(self.STATE)
if __name__ == '__main__':
print(LP.COPYRIGHT)
Return HOME