EntityScript™

# -*- coding: utf-8 -*-
"""
COPYRIGHT (C) 2020-2023 NEW ENTITY OPERATIONS INC. ALL RIGHTS RESERVED
INSTANCE: core_config
MODIFIED: 2023/05/09
OVERVIEW:

core_config allows you to turn certain system modules on or off during setup
 or at designated runtime intervals

This is the general configurations writer too.

You can use it to enforce certain modes at startup.

A counter of the entire tracked set of system attributes can also be provided.

A machine that has never been started has a 'has_lived' - and during the
 initial machine state, should be set to 0 in your settings file.
 after that, it should always be set to 1

A 'has_lived' counter of 1 will change a few settings configurations
 upon startup at each session and defer setting environment variables to
 designated sub-section program interfaces

Less than one (a fresh installation) will also setup default configurations
 to various standard .ini files

*Note, we don't pull from core_middlelayer here because the config file takes
 a hard coding out of convention to establish the default program structure.
 Mostly all of the figures in this file are symbolic but they're able to be
 extended to mute or elaborate on certain A->B->Z wiring as a 'MOD'

By default, everything is set to COREON when shipped.

If certain modules are overridden you're able to set them to 0 after the fact.
 Most of the file is mocked up for alteration and custom routines

All options that are meant to be changed on the fly also have on(), off()
 setters and various get methods too. This file doesn't have 'full coverage'
 of the program, but we're working to get everything covered soon.

"""
__version__ = "0.0.8"
__author__ = "Ryan McKenna"
__copyright__ = "Copyright (C) 2020-2023 New Entity Operations Inc."
__credits__ = [
 "Ryan McKenna",
 "New Entity Operations Inc.", "New Entity Operations, LLC"]
__email__ = "Operator@NewEntityOperations.com"
__license__ = "New Entity License"
__maintainer__ = "Ryan McKenna"
__status__ = "Production"

## MODE-> facilities
from MODE.facilities import (ConfigParser, COREON, COREOFF, CORE_SECTIONS,
 ec, has_lived, stdout)

## MODE-> debug_config
from MODE.debug_config import DEBUG_CONFIG

## from core_middlelayer
from core_middlelayer import VIRTUALPACKAGEID

def get_sections():
 """
 Quickly reference the sections in 'entity_config'
 This will be generated by the parser
 """
 DEBUG_CONFIG.provide_core_sections(SECTIONS=str(CORE_SECTIONS))

class CORE:
 """
 Build the program based on provided core components. These can be accessed
 through a default CORE object with each part of the program enforced strictly
 or loosely through the config.ini file

 'COREON' means ON, 'COREON' = ON
 'COREOFF' means OFF, 'COREOFF' = OFF,
 1 == ON, 0 == OFF

 ANY 'STRINGX' = COREX is a identifier module function that's being explicitly
 supplied to the program. These should be defined before they're built in,
 but it isn't required. When they're provided, modules are checked for
 verification purposes only, but additional check-routines may be supplied

 Unless the provided 'STRINGX' is tied to an executed instance elsewhere,
 it will represents a symbolic mock up of contextual origin that exists in
 memory, or that can be written to disk through loggin
 """
 ## Identify the script instance. This script instance is either 'verified' or
 ## 'unverified'. Verified packages gain a certain status over the network
 ## and when interacting with peers. Unverified packages don't gain the same
 ## attributes. Verification can be done using a compliant distributed lookup
 ## store
 PACKAGE_ID = ec.get('PACKAGE', 'ID')

 ## Each component is verified through config.ini
 ## When a new component (starting with part_* or meta_*) is added to the
 ## program, if you wish to enfoce strict package checking, it must be declared
 ## there under [CORE]
 ## Virtual options:
 ## write to the file-cache during runtime
 options_cache = COREOFF
 ## provide a specialized environment to the progam
 options_environment = COREON
 ## provide a virtual environment
 options_environment_virtual = COREON

 ## Base Setup scripts: found in .CORE/ root setup structure
 part_setup = COREON

 ## ACCESS
 meta_ACCESS = COREON
 ## ACTION
 meta_ACTION = COREON
 ## audit_home
 meta_audit_home = COREON
 ## BACKUP
 meta_BACKUP = COREON
 ## cache
 meta_cache = COREON
 ## CONFIG
 meta_CONFIG = COREON
 ## DATA
 meta_DATA = COREON
 ## db
 meta_db = COREON
 ## design
 meta_design = COREON
 ## DOCUMENTATION
 meta_DOCUMENTATION = COREON
 ## event
 meta_event = COREON
 ## evironment
 meta_environment = COREON
 ## FILTER
 meta_FILTER = COREON
 ## flag
 meta_flag = COREON
 ## HARDWARE
 meta_HARDWARE = COREON
 ## IDENTITY
 meta_IDENTITY = COREON
 ## image
 meta_image = COREON
 ## INFORMATION
 meta_INFORMATION = COREON
 ## INSTANCE
 meta_INSTANCE = COREON
 ## instance_process_audit
 meta_instance_process_audit = COREON
 ## KEYS
 meta_KEYS = COREON
 ## LICENSES
 meta_LICENSES = COREON
 ## LOG
 meta_LOG = COREON
 ## LOGIC
 meta_LOGIC = COREON
 ## MODE
 meta_MODE = COREON
 ## OPENPACKAGER
 meta_OPENPACKAGER = COREON
 ## parser
 meta_parser = COREON
 ## preset
 meta_preset = COREON
 ## RING
 meta_RING = COREON
 ## temple
 meta_temple = COREON

 ## Operations Scripts
 part_init = COREON
 part_CORE = COREON
 part_block_storage = COREON
 part_build_list = COREON
 part_build = COREON
 part_build_trine = COREON
 part_CHANGELOG = COREON
 part_classes = COREON
 part_configure = COREON
 part_core_add = COREON
 part_core_alerts = COREON
 part_core_architect = COREON
 part_core_config = COREON
 part_core_CORE = COREON
 part_core_count = COREON
 part_core_creator = COREON
 part_core_FRONTEND = COREON
 part_core_gatekeeper = COREON
 part_core_gather = COREON
 part_core_graphics = COREON
 part_core_hash = COREON
 part_core_interface = COREON
 part_core_language = COREON
 part_core_middlelayer = COREON
 part_core_modify = COREON
 part_core_navigator = COREON
 part_core_openpackager = COREON
 part_core_operations = COREON
 part_core_RUN = COREON
 part_core_seeker = COREON
 part_core_server = COREON
 part_core_START_SERVER = COREON
 part_core_transmitter = COREON
 part_core_url = COREON
 part_core_view = COREON
 part_file_system = COREON
 part_functionality = COREON
 part_gitignore = COREON
 part_hidden = COREON
 part_LICENSE = COREON
 part_MANIFEST = COREON
 part_memoryform = COREON
 part_notes = COREON
 part_origin = COREON
 part_packages = COREON
 part_proxy = COREON
 part_README = COREON
 part_rig = COREON
 part_runtime = COREON
 part_setup_extended = COREON
 part_storage_verification = COREON
 part_structures = COREON
 part_TRINE = COREON
 part_TRINE_configuration = COREON

 ## Base modules
 part_module_corehost_BROWSEMEH = COREON
 part_module_corehost_EVENTLOLLI = COREON
 part_module_corehost_REMINDME = COREON
 ## Standard Extensions
 part_module_corehost_StandardOutput01 = COREON
 part_module_corehost_StandardVisualBuild02 = COREON
 part_module_corehost_StandardExtension03 = COREON
 part_module_corehost_StandardDocumentViewer04 = COREON
 ## Utility Scripts: These can be found in OPENPACKAGER.internal
 part_module_internal_constructed_class = COREON
 part_module_internal_fetch_ore = COREON
 part_module_internal_ingest_commands = COREON
 part_module_internal_INDEX_ORGANIZER_KEY_LIST_INDEX = COREON


## GET_VALUES
class GET_VALUES:
 """
 Provide generic print/setup routines for various hard-coded modules
 """
 def default():
  """
  Depending on the settings the operator chooses during setup,
  these will be executed according to the above design
  """
  # Define custom configuration options for each base directory
  class ACCESS:
   """
   Establish the ACCESS directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="ACCESS")

  class ACTION:
   """
   Establish the ACTION directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="ACTION")

  class audit_home:
   """
   Establish the audit_home directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="audit_home")

  class BACKUP:
   """
   Establish the BACKUP directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="BACKUP")

  class cache:
   """
   Establish the cache directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="cache")

  class CONFIG:
   """
   Establish the CONFIG directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="CONFIG")

  class DATA:
   """
   Establish the DATA directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="DATA")

  class db:
   """
   Establish the db directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="db")

  class design:
   """
   Establish the design directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="design")

  class DOCUMENTATION:
   """
   Establish the DOCUMENTATION directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="DOCUMENTATION")

  class environment:
   """
   Establish the design directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="environment")

  class event:
   """
   Establish the event directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="event")

  class FILTER:
   """
   Establish the FILTER directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="FILTER")

  class flag:
   """
   Establish the flag directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="flag")

  class HARDWARE:
   """
   Establish the HARDWARE directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="HARDWARE")

  class IDENTITY:
   """
   Establish the IDENTITY directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="IDENTITY")

  class image:
   """
   Establish the image directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="image")

  class INFORMATION:
   """
   Establish the INFORMATION directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="INFORMATION")

  class INSTANCE:
   """
   Establish the design directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="INSTANCE")

  class instance_process_audit:
   """
   Establish the instance_process_audit directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="instance_process_audit")

  class KEYS:
   """
   Establish the KEYS directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="KEYS")

  class LICENSES:
   """
   Establish the LICENSES directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="LICENSES")

  class LOG:
   """
   Establish the LOG directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="LOG")

  class LOGIC:
   """
   Establish the LOGIC directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="LOGIC")

  class MODE:
   """
   Establish the MODE directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="MODE")

  class OPENPACKAGER:
   """
   Establish the OPENPACKAGER directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="OPENPACKAGER")

  class parser:
   """
   Establish the parser directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="parser")

  class preset:
   """
   Establish the preset directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="preset")

  class RING:
   """
   Establish the RING directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="RING")

  class temple:
   """
   Establish the temple directory meta-structure
   """
   def set():
    """
    set() will either point directly to this folder or through a symlink
    to a folder chosen here
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="ESTABLISH",
      STRUCTURE="temple")

  class FEATURES():
   """
   Establish the FEATURES directory meta-structure
   """
   def setup():
    """
    Establish a customized make MANIFEST routine
    A defined feature: make->manifest: Default none
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="setup",
      STRUCTURE="FEATURES")

   def make_manifest():
    """
    Establish a customized make MANIFEST routine
    A defined feature: make->manifest: Default none
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="make_manifest",
      STRUCTURE="FEATURES")

   def wipe_fresh():
    """
    Establish a customized make MANIFEST routine
    A defined feature: wipe->fresh: Default none
    """
    DEBUG_CONFIG.provide_meta_structure_logic(LOGIC="** wipe ** fresh **",
      STRUCTURE="FEATURES")

  ## Provide a generic config RUNNER
  DEBUG_CONFIG.set_meta_structures()
  ## ACCESS
  ACCESS.set()
  ## ACTION
  ACTION.set()
  ## audit_home
  audit_home.set()
  ## BACKUP
  BACKUP.set()
  ## cache
  cache.set()
  ## CONFIG
  CONFIG.set()
  ## DATA
  DATA.set()
  ## db
  db.set()
  ## design
  design.set()
  ## DOCUMENTATION
  DOCUMENTATION.set()
  ## event
  event.set()
  ## evironment
  environment.set()
  ## FILTER
  FILTER.set()
  ## flag
  flag.set()
  ## HARDWARE
  HARDWARE.set()
  ## IDENTITY
  IDENTITY.set()
  ## image
  image.set()
  ## INFORMATION
  INFORMATION.set()
  ## INSTANCE
  INSTANCE.set()
  ## instance_process_audit
  instance_process_audit.set()
  ## KEYS
  KEYS.set()
  ## LICENSES
  LICENSES.set()
  ## LOG
  LOG.set()
  ## LOGIC
  LOGIC.set()
  ## MODE
  MODE.set()
  ## OPENPACKAGER
  OPENPACKAGER.set()
  ## parser
  parser.set()
  ## preset
  preset.set()
  ## RING
  RING.set()
  ## temple
  temple.set()
  ## FEATURES-> build extras
  FEATURES.setup()
  FEATURES.wipe_fresh()
  FEATURES.make_manifest()
  ## Set meta-values
  DEBUG_CONFIG.set_meta_values()
  ## Variables are set according to the desired runtime-checking
  ## methodology
  ## PACKAGER_ID_
  ec.set('PACKAGE', 'ID', CORE.PACKAGE_ID)
  ## options_*
  ec.set('OPTIONSDEFAULT', 'options_cache', CORE.options_cache)
  ec.set('OPTIONSDEFAULT', 'options_environment',
   CORE.options_environment)
  ec.set('OPTIONSDEFAULT', 'options_environment_virtual',
   CORE.options_environment_virtual)
  ## part_*
  ec.set('CORE', 'setup', CORE.part_setup)
  ## meta_*
  ## METADEFAULT
  ## ACCESS
  ec.set('METADEFAULT', 'meta_ACCESS', CORE.meta_ACCESS)
  ## ACTION
  ec.set('METADEFAULT', 'meta_ACTION', CORE.meta_ACTION)
  ## audit_home
  ec.set('METADEFAULT', 'meta_audit_home', CORE.meta_audit_home)
  ## BACKUP
  ec.set('METADEFAULT', 'meta_BACKUP', CORE.meta_BACKUP)
  ## cache
  ec.set('METADEFAULT', 'meta_cache', CORE.meta_cache)
  ## CONFIG
  ec.set('METADEFAULT', 'meta_CONFIG', CORE.meta_CONFIG)
  ## DATA
  ec.set('METADEFAULT', 'meta_DATA', CORE.meta_DATA)
  ## db
  ec.set('METADEFAULT', 'meta_db', CORE.meta_db)
  ## design
  ec.set('METADEFAULT', 'meta_design', CORE.meta_design)
  ## DOCUMENTATION
  ec.set('METADEFAULT', 'meta_DOCUMENTATION',
   CORE.meta_DOCUMENTATION)
  ## event
  ec.set('METADEFAULT', 'meta_event', CORE.meta_event)
  ## evironment
  ec.set('METADEFAULT', 'meta_environment',
   CORE.meta_environment)
  ## FILTER
  ec.set('METADEFAULT', 'meta_FILTER', CORE.meta_FILTER)
  ## flag
  ec.set('METADEFAULT', 'meta_flag', CORE.meta_flag)
  ## HARDWARE
  ec.set('METADEFAULT', 'meta_HARDWARE', CORE.meta_HARDWARE)
  ## IDENTITY
  ec.set('METADEFAULT', 'meta_IDENTITY', CORE.meta_IDENTITY)
  ## image
  ec.set('METADEFAULT', 'meta_image', CORE.meta_image)
  ## INFORMATION
  ec.set('METADEFAULT', 'meta_INFORMATION',
   CORE.meta_INFORMATION)
  ## INSTANCE
  ec.set('METADEFAULT', 'meta_INSTANCE', CORE.meta_INSTANCE)
  ## instance_process_audit
  ec.set('METADEFAULT', 'meta_instance_process_audit',
   CORE.meta_instance_process_audit)
  ## KEYS
  ec.set('METADEFAULT', 'meta_KEYS', CORE.meta_KEYS)
  ## LICENSES
  ec.set('METADEFAULT', 'meta_LICENSES', CORE.meta_LICENSES)
  ## LOG
  ec.set('METADEFAULT', 'meta_LOG', CORE.meta_LOG)
  ## LOGIC
  ec.set('METADEFAULT', 'meta_LOGIC', CORE.meta_LOGIC)
  ## MODE
  ec.set('METADEFAULT', 'meta_MODE', CORE.meta_MODE)
  ## OPENPACKAGER
  ec.set('METADEFAULT', 'meta_OPENPACKAGER',
   CORE.meta_OPENPACKAGER)
  ## parser
  ec.set('METADEFAULT', 'meta_parser', CORE.meta_parser)
  ## preset
  ec.set('METADEFAULT', 'meta_preset', CORE.meta_preset)
  ## RING
  ec.set('METADEFAULT', 'meta_RING', CORE.meta_RING)
  ## temple
  ec.set('METADEFAULT', 'meta_temple', CORE.meta_temple)
  ## Build the standardized structure
  ## Operations Scripts
  ec.set('CORE', 'part_init', CORE.part_init)
  ec.set('CORE', 'part_CORE', CORE.part_CORE)
  ec.set('CORE', 'part_block_storage', CORE.part_block_storage)
  ec.set('CORE', 'part_build_list', CORE.part_build_list)
  ec.set('CORE', 'part_build', CORE.part_build)
  ec.set('CORE', 'part_build_trine', CORE.part_build_trine)
  ec.set('CORE', 'part_CHANGELOG', CORE.part_CHANGELOG)
  ec.set('CORE', 'part_classes', CORE.part_classes)
  ec.set('CORE', 'part_configure', CORE.part_configure)
  ec.set('CORE', 'part_core_add', CORE.part_core_add)
  ec.set('CORE', 'part_core_alerts', CORE.part_core_alerts)
  ec.set('CORE', 'part_core_architect', CORE.part_core_architect)
  ec.set('CORE', 'part_core_config', CORE.part_core_config)
  ec.set('CORE', 'part_core_CORE', CORE.part_core_CORE)
  ec.set('CORE', 'part_core_count', CORE.part_core_count)
  ec.set('CORE', 'part_core_creator', CORE.part_core_creator)
  ec.set('CORE', 'part_core_FRONTEND', CORE.part_core_FRONTEND)
  ec.set('CORE', 'part_core_gatekeeper', CORE.part_core_gatekeeper)
  ec.set('CORE', 'part_core_gather', CORE.part_core_gather)
  ec.set('CORE', 'part_core_graphics', CORE.part_core_graphics)
  ec.set('CORE', 'part_core_hash', CORE.part_core_hash)
  ec.set('CORE', 'part_core_interface', CORE.part_core_interface)
  ec.set('CORE', 'part_core_language', CORE.part_core_language)
  ec.set('CORE', 'part_core_middlelayer', CORE.part_core_middlelayer)
  ec.set('CORE', 'part_core_modify', CORE.part_core_modify)
  ec.set('CORE', 'part_core_navigator', CORE.part_core_navigator)
  ec.set('CORE', 'part_core_openpackager',
   CORE.part_core_openpackager)
  ec.set('CORE', 'part_core_operations', CORE.part_core_operations)
  ec.set('CORE', 'part_core_RUN', CORE.part_core_RUN)
  ec.set('CORE', 'part_core_seeker', CORE.part_core_seeker)
  ec.set('CORE', 'part_core_server', CORE.part_core_server)
  ec.set('CORE', 'part_core_START_SERVER',
   CORE.part_core_START_SERVER)
  ec.set('CORE', 'part_core_transmitter', CORE.part_core_transmitter)
  ec.set('CORE', 'part_core_url', CORE.part_core_url)
  ec.set('CORE', 'part_core_view', CORE.part_core_view)
  ec.set('CORE', 'part_file_system', CORE.part_file_system)
  ec.set('CORE', 'part_functionality', CORE.part_functionality)
  ec.set('CORE', 'part_gitignore', CORE.part_gitignore)
  ec.set('CORE', 'part_hidden', CORE.part_hidden)
  ec.set('CORE', 'part_LICENSE', CORE.part_LICENSE)
  ec.set('CORE', 'part_MANIFEST', CORE.part_MANIFEST)
  ec.set('CORE', 'part_memoryform', CORE.part_memoryform)
  ec.set('CORE', 'part_notes', CORE.part_notes)
  ec.set('CORE', 'part_origin', CORE.part_origin)
  ec.set('CORE', 'part_packages', CORE.part_packages)
  ec.set('CORE', 'part_proxy', CORE.part_proxy)
  ec.set('CORE', 'part_README', CORE.part_README)
  ec.set('CORE', 'part_rig', CORE.part_rig)
  ec.set('CORE', 'part_runtime', CORE.part_runtime)
  ec.set('CORE', 'part_setup_extended', CORE.part_setup_extended)
  ec.set('CORE', 'part_storage_verification',
   CORE.part_storage_verification)
  ec.set('CORE', 'part_structures', CORE.part_structures)
  ec.set('CORE', 'part_TRINE', CORE.part_TRINE)
  ec.set('CORE', 'part_TRINE_configuration',
   CORE.part_TRINE_configuration)
  ## Build the base utility structure
  ec.set('CONSTRUCTEDCLASS', 'CORE',
   CORE.part_module_internal_constructed_class)
  ec.set('MAPPERORE', 'fetch_ORE', CORE.part_module_internal_fetch_ore)
  ec.set('MAPPERCOMMANDS', 'ingest_commands',
   CORE.part_module_internal_ingest_commands)
  ## ADDON
  ec.set('ADDON', 'browsemeh', CORE.part_module_corehost_BROWSEMEH)
  ec.set('ADDON', 'eventlolli', CORE.part_module_corehost_EVENTLOLLI)
  ec.set('ADDON', 'remindme', CORE.part_module_corehost_REMINDME)
  ## Standard
  ec.set('STANDARD', 'standardoutput', CORE.part_module_corehost_BROWSEMEH)
  ec.set('STANDARD', 'standardvisualbuild', CORE.part_module_corehost_BROWSEMEH)
  ec.set('STANDARD', 'standardextension', CORE.part_module_corehost_BROWSEMEH)
  ec.set('STANDARD', 'standarddocumentviewer',
   CORE.part_module_corehost_BROWSEMEH)
  ## Indexer
  ec.set('INDEXER', 'index_organizer_key_list_index',
   CORE.part_module_internal_INDEX_ORGANIZER_KEY_LIST_INDEX)

## SET_VALUES
class SET_VALUES:
 """
 Pre-load any desired set values here as a routine
 """
 def default():
  """
  Provide a default run-routine for setting custom program-values
  """
  DEBUG_CONFIG.set_meta_values_custom(QUE="")

## Default runners
GET_VALUES.default()
SET_VALUES.default()

## OPENPACKAGER
class OPENPACKAGER:
 """
 Setup and configure 'OPENPACKAGER' sessions: Retrieval, Communications,
 and age restrictions on content
 """
 sections_openpackager_get_encryption = COREOFF
 sections_openpackager_get_OPENPACKAGERPATH = COREOFF
 sections_openpackager_get_private = COREOFF
 sections_openpackager_get_public = COREOFF
 sections_openpackager_get_status = COREOFF
 def get():
  """
  check the local configurations for 'OPENPACKAGER'
  """
  sections_openpackager_get_status = \
   ec.get('OPENPACKAGER', 'status')
  sections_openpackager_get_openpackagerpath = \
   ec.get('OPENPACKAGER', 'OPENPACKAGERPATH')
  sections_openpackager_get_public = \
   ec.get('OPENPACKAGER', 'public')
  sections_openpackager_get_private = \
   ec.get('OPENPACKAGER', 'private')
  sections_openpackager_get_encryption = \
   ec.get('OPENPACKAGER', 'encryption')
  DEBUG_CONFIG.set_openpackager_values(
   ENCRYPTION=sections_openpackager_get_encryption,
   PATH=sections_openpackager_get_openpackagerpath,
   PRIVATE=sections_openpackager_get_private,
   PUBLIC=sections_openpackager_get_public,
   STATUS=sections_openpackager_get_public)

 def default():
  """
  Setup the default 'OPENPACKAGER' slug
  """
  ## STANDARD FOLDER
  sections_openpackagerpath_path = \
   ec.set('OPENPACKAGER', 'OPENPACKAGERPATH', 'OPENPACKAGER/')
  ec.write(stdout)

 def binary_status_default():
  sections_openpackagerpath_status = \
   ec.set('OPENPACKAGER', 'clean', 'yes')
  ec.write(stdout)

 def binary_public_default():
  """
  Allow binaries not tracked by C.ORE
  """
  sections_openpackagerpath_public = \
   ec.set('OPENPACKAGER', 'public', 'no')
  ec.write(stdout)

 def binary_private_default():
  """
  Allow binaries to exist in private locations
  """
  sections_openpackagerpath_private = \
   ec.set('OPENPACKAGER', 'private', 'yes')
  ec.write(stdout)

 def binary_encryption_default():
  """
  Encrypt binaries while in memory
  """
  sections_openpackagerpath_encryption = \
   ec.set('OPENPACKAGER', 'encryption', 'on')
  ec.write(stdout)

 def binary_status_null():
  """
  Kill unknown binaries. Set to 'failed' if this isn't running by default
  This ensures an override will be needed deeper in the program.
  Where will have to be specified by the operator
  """
  sections_openpackagerpath_status = \
   ec.set('OPENPACKAGER', 'status', 'failed')
  ec.write(stdout)

 def binary_public_null():
  """
  Allow public binaries to run
  """
  sections_openpackagerpath_public = \
   ec.set('OPENPACKAGER', 'public', 'yes')
  ec.write(stdout)

 def binary_private_null():
  """
  Allow binaries of unknown origins or ones imported manually to run
  """
  sections_openpackagerpath_private = \
   ec.set('OPENPACKAGER', 'private', 'no')
  ec.write(stdout)

 def binary_encryption_default():
  """
  Encrypt binary objects while at rest
  """
  sections_openpackagerpath_encryption = \
   ec.set('OPENPACKAGER', 'encryption', 'off')
  ec.write(stdout)

class OPENPACKAGERDEFAULT:
 """
 'OPENPACKAGER' default setup. This is where pre-built settings are
 executed
 """
 def make():
  """
  Setup 'OPENPACKAGER' according to the recommended settings
  """
  ## Run .get() to get the status of the current instance
  OPENPACKAGER.get()
  ## You only need to run 1 of these to trigger the STD read
  OPENPACKAGER.default()
  #OPENPACKAGER.binary_status_default()
  #OPENPACKAGER.binary_public_default()
  #OPENPACKAGER.binary_private_default()
  #OPENPACKAGER.binary_encryption_default()
  #OPENPACKAGER.binary_status_null()
  #OPENPACKAGER.binary_public_null()
  #OPENPACKAGER.binary_private_null()
  #OPENPACKAGER.binary_encryption_default()

## Create the default values for your OpenPackager instance
OPENPACKAGERDEFAULT.make()

## Output: Configurations
DEBUG_CONFIG.provide_current_configurations()

## datascript_id
class DATASCRIPTID:
 """
 Establish local file capabilities here. All files operate
 through a .entity/.ds relationship
 """
 def get():
  """
  get the current datascript of the instance.
  This can be time-stammped on the ledger
  or operating as a stictly local thread
  default: No routines
  """
  datascriptid_status = ec.get('DATASCRIPTID', 'status')
  print(datascriptid_status)
 def on():
  """
  Turn local storage on
  default: No routines
  """
  sections_datascript_id_on = ec.set('DATASCRIPTID', 'status', 'on')
  print(sections_datascript_id_on)
 def off():
  """
  Turn local storage off
  default: No routines
  """
  sections_datascript_id_off = ec.set('DATASCRIPTID', 'status', 'off')
  print(sections_datascript_id_off)

## Confirm the datascript_id options
print('datascript_id: '+str(DATASCRIPTID.get()))

## include_module
class INCLUDEMODULE:
 """
 Modules: Local and 3rd party that run on your system
 """
 def get():
  """
  Get the 3rd party module status on the system
  default: None mapped
  """
  sections_include_module_get = ec.get('INCLUDEMODULE', 'status')
  print(sections_include_module_get)
 def on():
  """
  Turn 3rd party modules on
  default: Disabled
  """
  sections_include_module_on = ec.set('INCLUDEMODULE', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn 3rd party modules off
  default: Disabled
  """
  sections_include_module_off = ec.set('INCLUDEMODULE', 'status', 'off')
  ec.write(stdout)

## Display the current environment modules
print('include_module: '+str(INCLUDEMODULE.get()))

## DEFINITION
class DEFINITION:
 """
 Definitions that determine what's allowed to operate on your system.
 They can be mapped to take a custom format
 """
 def get():
  """
  Get the all defined definitions allowed to operate on your machine
  default: None
  """
  sections_definition_get = ec.get('DEFINITION', 'status')
  print(sections_definition_get)
 def on():
  """
  Turn on extended definitions for your machine (less secure)
  default: None
  """
  sections_definition_on = ec.set('DEFINITION', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn off extended definitions for your machine (less secure)
  default: None
  """
  sections_definition_off = ec.set('DEFINITION', 'status', 'off')
  ec.write(stdout)

## Display the current allowed definitions
print('DEFINITION: '+str(DEFINITION.get()))

## scale_id_module
class SCALE:
 """
 Visual and scalar coordinate systems for your machine.
 This requires additional configurations
 """
 def get():
  """
  Get the status of the screenscale
  You're customizing visual output or utilizing default scale of 1
  """
  sections_scale_id_module_get = ec.get('SCALE', 'status')
  print(sections_scale_id_module_get)
 def now():
  """
  Get or set the current default visual aplifying measure
  """
  sections_scale_id_module_now = ec.get('SCALE', 'NOW')
  print(sections_scale_id_module_now)
 def on():
  """
  Turn visual amplification on
  """
  sections_scale_id_module_on = ec.set('SCALE', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn visual amplification off
  """
  sections_scale_id_module_off = ec.set('SCALE', 'status', 'off')
  ec.write(stdout)

# Print the scalar objects that govern your system
print('SCALE Status: '+str(SCALE.get()))
print('SCALE Now: '+str(SCALE.now()))

## Provide a Virtual Human to the instance based on user-defined
## or community presets
DEBUG_CONFIG.virtual_human_setup()

## Define a virutal default digital body. This is the 'default_body'
class VIRTUALBODY:
 """
 A virtual body is a computer generated avatar
 A human can build a character with various likeness.
 They can also take on defined properties
 according to a random or pre-defined format.
 """
 def get():
  """
  Get your current 'VIRTUALBODY' data
  """
  sections_default_body_get = ec.get('VIRTUALBODY', 'status')
  print(sections_default_body_get)
 def on():
  """
  Turn on manual virtual body editing using the marketplace.
  This is only valid if a compliant 3d marketplace is linked
  default_market: None specified
  """
  sections_default_body_on = ec.set('VIRTUALBODY', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn off manual virtual body editing and block the marketplace
  default_market: None specified
  """
  sections_default_body_off = ec.set('VIRTUALBODY', 'status', 'off')
  ec.write(stdout)

## Dispaly your 'VIRTUALBODY' attributes if the status is on
DEBUG_CONFIG.provide_get_value_character(
 VALUE=str(VIRTUALBODY.get()))

## Adult concepts: Allow or Disallow Adult Concepts
class XALL:
 """
 If the operator is 18+ or 21+ in some juristictions, allow adult content
 Certain features are disabled in virtual human mode if the operator
 is not certified to be over 18 years old.
 """
 def get():
  """
  Check if the operator is currently accessing or allowing adult content
  """
  sections_xall_get = ec.get('XALL', 'status')
  print(sections_xall_get)
 def on():
  """
  Turn on adult content (requires authorization)
  """
  sections_xall_on = ec.set('XALL', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn off adult content: Requries operator admin status
  """
  sections_xall_off = ec.set('XALL', 'status', 'off')
  ec.write(stdout)

## See your adult filter
DEBUG_CONFIG.provide_get_value_character(
 VALUE=str(XALL.get()))

## character
class CHARACTER:
 """
 Define the character of your 'VIRTUALBODY'
 """
 def get():
  """
  Get the current 'CHARACTER' descriptor
  This will hold virtual attributes that translate into virtual avatar
  linked options
  """
  sections_character_get = ec.get('CHARACTER', 'status')
  print(sections_character_get)
 def on():
  """
  Turn the current 'CHARACTER' build  module on
  AI can generate these in a variety of formats
  """
  sections_character_on = ec.set('CHARACTER', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn the current 'CHARACTER' build module off
  """
  sections_character_off = ec.set('CHARACTER', 'status', 'off')
  ec.write(stdout)

## See the final character attributes chosen
DEBUG_CONFIG.provide_get_value_character(
 VALUE=CHARACTER.get())

## default_age
class DEFAULT_AGE:
 """
 Define the default minimum age for peers and virtually generated AI human
 content
 """
 def get_status():
  """
  Peer Age Satus:
  The current minimum age and range of peers
  Impacts human related content being generated
  """
  sections_default_age_get = ec.get('DEFAULT_AGE', 'status')
  print(sections_default_age_get)
 def get_number():
  """
  By Number: Minimum age and range of peers/human content
  being gnerated by number
  """
  sections_default_age_number = ec.get('DEFAULT_AGE', 'number')
  print(sections_default_age_number)
 def on():
  """
  Turn on the manual override
  """
  sections_default_age_on = ec.set('DEFAULT_AGE', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn off the manual override
  """
  sections_default_age_off = ec.set('DEFAULT_AGE', 'status', 'off')
  ec.write(stdout)

## Provide an age gated instance
DEBUG_CONFIG.provide_get_value_default_age(
 AGE=DEFAULT_AGE.get_number(),
 AGE_STATUS=DEFAULT_AGE.get_status())

## Feature: Mod Shock: Enable CGI Items of Shock Value, i.e digital blood
class MODSHOCK:
 """
 Shock content module: Toggle Shock Values
 """
 def get():
  """
  get the current status of your shock module - if off, or not present,
  default will be no content with modshock displayed
  """
  sections_default_mod_shock_get = ec.get('MODSHOCK', 'status')
  print(sections_default_mod_shock_get)
 def on():
  """
  Turn on shocking content (consent)
  """
  sections_default_mod_shock_on = ec.set('MODSHOCK', 'status', 'on')
  ec.write(stdout)
 def off():
  """
  Turn on shocking content
  """
  sections_default_mod_shock_off = ec.set('MODSHOCK', 'status', 'off')
  ec.write(stdout)

## Modules: Shock Option Display
DEBUG_CONFIG.provide_get_value_modshock(
 VALUE=MODSHOCK.get())

## Conclude output
DEBUG_CONFIG.virtual_human_setup()