EntityScript™

"""
Copyright (C) 2020 New Entity Operations Inc.

ALL RIGHTS RESERVED

core_config allows you to turn certain system modules on or off at setup

This is the general configurations writer too and upon the startup
a counter of the entire tracked set of system attributes

A machine that has never been started has a 'has_lived' counter of 0

A 'has_lived' counter of 1 will change a few settings configurations upon startup at each session

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 wiring
as a 'MOD'

By default everything is set to COREON. 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.

"""
## Imports: Standard
from sys import (
 stdout,
)
## Imports: Custom
from configparser import ConfigParser
CONFIGFOLDER = 'CONFIG/'
CONFIGLOGICFILE = 'config.ini'

## Establish the Configuration object
entity_config = ConfigParser()
ec = entity_config

## Load the configuration script
ec.read(CONFIGFOLDER+CONFIGLOGICFILE)
SECTIONS = ec.sections()

## Determine if the system has ever existed
has_lived = 1

## Establish on/off ques
COREON = str(1)
COREOFF = str(0)

def get_sections():
    """
    Quickly reference the sections in 'entity_config'

    This will be generated by the parser

    """
    print(SECTIONS)

class CORE:
    """
    'COREON' means ON, 'COREOFF' means OFF
    'COREOFF' = OFF, 1 = ON

    ANY 'STRINGX' = COREX is a identifier module function
    and is used for verification only.

    Unless this 'STRINGX' is tied to an executed instance elsewhere,
    it will just represents a symbolic mock up of contextual origin

    """
    ## Unique Scripts: Installation identifier Specific
    PACKAGE_ID_include_core_config = 'XHLH2IPHNE037N'
    ## Virtual options: Default disabled
    options_on_pycache = COREOFF
    options_on_environment_extra = COREON
    ## Base Build Scripts: C.ORE Main Scripts found in .CORE/ root structure
    part_setup_all_packages = COREON
    part_setup_build_list = COREON
    ## Base modules
    part_module_corehost_BROWSEMEH = COREON
    part_module_corehost_EVENTLOLLI = COREON
    part_module_corehost_REMINDME = COREON
    # Standard Operations
    part_module_corehost_StandardOutput01 = COREON
    part_module_corehost_StandardVisualBuild02 = COREON
    part_module_corehost_StandardExtension03 = COREON
    part_module_corehost_StandardDocumentViewer04 = COREON 
    ## Utility Scripts: This 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
    ## Base Setup Scripts: C.ORE Main Scripts found in .CORE/ root structure
    meta_include_CORE = COREON
    ## Directory Setup
    meta_ACCESS = COREON
    meta_CONFIG = COREON
    meta_DATA = COREON
    meta_DOCUMENTATION = COREON
    meta_FILTER = COREON
    meta_HARDWARE = COREON
    meta_IDENTITY = COREON
    meta_LICENSES = COREON
    meta_OPENPACKAGER = COREON
    meta_RING = COREON
    # Operations Scripts
    part_include_core_add = COREON
    part_include_core_alerts = COREON
    part_include_core_architect = COREON
    part_include_core_build = COREON
    ## Operator Defined: Operator Specific Functions
    part_include_core_config = COREON
    part_include_core_CORE = COREON
    part_include_core_count = COREON
    part_include_core_creator = COREON
    part_include_core_FRONTEND = COREON
    part_include_core_gatekeeper = COREON
    part_include_core_gather = COREON
    part_include_core_graphics = COREON
    part_include_core_hash = COREON
    part_include_core_interface = COREON
    part_include_core_language = COREON
    part_include_core_middlelayer = COREON
    part_include_core_modify = COREON
    part_include_core_navigator = COREON
    part_include_core_openpackager = COREON
    part_include_core_operations = COREON
    part_include_core_RUN = COREON
    part_include_core_seeker = COREON
    part_include_core_server = COREON
    part_include_core_settings = COREON
    part_include_core_START_SERVER = COREON
    part_include_core_transmitter = COREON
    part_include_core_url = COREON
    part_include_core_view = COREON
    part_include_init = COREON
    part_include_MANIFEST = COREON
    part_include_setup = COREON

class GET_VALUES:
    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 folder
            """
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: ACCESS/ Established')

        class CONFIG:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: CONFIG/ Established')

        class DATA:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: DATA/ Established')


        class DOCUMENTATION:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: DOCUMENTATION/ Established')

        class FILTER:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: FILTER/ Established')

        class HARDWARE:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: HARDWARE/ Established')

        class IDENTITY:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: IDENTITY/ Established')

        class LICENSES:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: LICENSES/ Established')

        class OPENPACKAGER:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: OPENPACKAGER/ Established')

        class RING:
            def set():
                """
                set() will either point directly to this folder or through a symlink
                to a folder chosen here

                """
                print('FOLDER: RING/ Established')

        class FEATURES():
            def setup():
                """
                Establish a customized make MANIFEST routine

                A defined feature: make->manifest: Default none

                """
                print("All features:")
            def make_manifest():
                """
                Establish a customized make MANIFEST routine

                A defined feature: make->manifest: Default none

                """
                print('Feature: make->manifest')
            def wipe_fresh():
                """
                Establish a customized make MANIFEST routine

                A defined feature: wipe->fresh: Default none

                """
                print('Feature: wipe->fresh')

        print("-------------------------------")
        print("SET_VALUES: meta")
        print("-------------------------------")
        # SET_VALUES.default()
        ACCESS.set()
        CONFIG.set()
        DATA.set()
        DOCUMENTATION.set()
        FILTER.set()
        HARDWARE.set()
        IDENTITY.set()
        LICENSES.set()
        OPENPACKAGER.set()
        RING.set()

        ## Build extras
        FEATURES.setup()
        FEATURES.wipe_fresh()
        FEATURES.make_manifest()

        print("-------------------------------")
        print("PRINT CURRENT VALUES: meta")
        print("-------------------------------")

        # options_
        ec.set(
            'OPTIONSDEFAULT', 'options_on_pycache',
            CORE.options_on_pycache
        )
        ec.set(
            'OPTIONSDEFAULT', 'core-env',
            CORE.options_on_environment_extra
        )

       # PACKAGER_ID_
        ec.set(
            'CORE', 'PACKAGE_ID',
            CORE.PACKAGE_ID_include_core_config
        )

       # part_
        ec.set(
            'CORE', 'core_init',
            CORE.part_include_init
        )
        ec.set(
            'CORE', 'MANIFEST',
            CORE.part_include_MANIFEST
        )

       # part_setup_
        ec.set(
            'CORE', 'core_build_list',
            CORE.part_setup_build_list
        )
        ec.set(
            'CORE', 'core_setup',
            CORE.part_setup_all_packages
        )

        # METADEFAULT
        ec.set(
            'METADEFAULT', 'meta_ACCESS',
            CORE.meta_ACCESS
        )
        ec.set(
            'METADEFAULT', 'meta_CONFIG',
            CORE.meta_CONFIG
        )
        ec.set(
            'METADEFAULT', 'meta_DATA',
            CORE.meta_DATA
        )
        ec.set(
            'METADEFAULT', 'meta_DOCUMENTATION',
            CORE.meta_DOCUMENTATION
        )
        ec.set(
            'METADEFAULT', 'meta_FILTER',
            CORE.meta_FILTER
        )
        ec.set(
            'METADEFAULT', 'meta_HARDWARE',
            CORE.meta_HARDWARE
        )
        ec.set(
            'METADEFAULT', 'meta_IDENTITY',
            CORE.meta_IDENTITY
        )
        ec.set(
            'METADEFAULT', 'meta_LICENSES',
             CORE.meta_LICENSES
        )
        ec.set(
            'METADEFAULT', 'meta_OPENPACKAGER',
             CORE.meta_OPENPACKAGER
        )

        ## 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
        )

        ## Build the standardized structure
        ec.set(
            'CORE', 'CORE',
            CORE.part_include_core_CORE
        )
        ec.set(
            'CORE', 'core_add',
            CORE.part_include_core_add
        )
        ec.set(
            'CORE', 'core_alerts',
            CORE.part_include_core_alerts
        )
        ec.set(
            'CORE', 'core_architect',
            CORE.part_include_core_architect
        )
        ec.set(
            'CORE', 'core_build',
            CORE.part_include_core_build
        )
        ec.set(
            'CORE', 'core_config',
            CORE.part_include_core_config
        )
        ec.set(
            'CORE', 'core_count',
            CORE.part_include_core_count
        )
        ec.set(
            'CORE', 'core_creator',
            CORE.part_include_core_creator
        )
        ec.set(
            'CORE', 'core_FRONTEND',
            CORE.part_include_core_FRONTEND
        )
        ec.set(
            'CORE', 'core_gatekeeper',
            CORE.part_include_core_gatekeeper
        )
        ec.set(
            'CORE', 'core_gather',
            CORE.part_include_core_gather
        )
        ec.set(
            'CORE', 'core_graphics',
            CORE.part_include_core_graphics
        )
        ec.set(
            'CORE', 'core_hash',
            CORE.part_include_core_hash
        )
        ec.set(
            'CORE', 'core_interface',
            CORE.part_include_core_interface
        )
        ec.set(
            'CORE', 'core_language',
            CORE.part_include_core_language
        )
        ec.set(
            'CORE', 'core_middlelayer',
            CORE.part_include_core_middlelayer
        )
        ec.set(
            'CORE', 'core_modify',
            CORE.part_include_core_modify
        )
        ec.set(
            'CORE', 'core_navigator',
            CORE.part_include_core_navigator
        )
        ec.set(
            'CORE', 'core_openpackager',
            CORE.part_include_core_openpackager
        )
        ec.set(
            'CORE', 'core_operations',
            CORE.part_include_core_operations
        )
        ec.set(
            'CORE', 'core_RUN',
            CORE.part_include_core_RUN
        )
        ec.set(
            'CORE', 'core_seeker',
            CORE.part_include_core_seeker
        )
        ec.set(
            'CORE', 'core_server',
            CORE.part_include_core_server
        )
        ec.set(
            'CORE', 'core_settings',
            CORE.part_include_core_settings
        )
        ec.set(
            'CORE', 'core_START_SERVER',
            CORE.part_include_core_START_SERVER
        )
        ec.set(
            'CORE', 'core_transmitter',
            CORE.part_include_core_transmitter
        )
        ec.set(
            'CORE', 'core_url',
            CORE.part_include_core_url
        )
        ec.set(
            'CORE', 'core_view',
            CORE.part_include_core_view
        )


class SET_VALUES:
     def default():
         print("No set values have been established yet.")

GET_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
    #sections = sections_openpackager_get_status+\
    #sections_openpackager_get_OPENPACKAGERPATH+\
    #sections_openpackager_get_public+\
    #sections_openpackager_get_private+\
    #sections_openpackager_get_encryption
    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')
        print("-------------------------------")
        print("OpenPackager 'status_check'")
        print("-------------------------------")
        print(
            '1. status: '+sections_openpackager_get_status+'\n'+\
            '2. path: '+sections_openpackager_get_openpackagerpath+'\n'+\
            '3. public: '+sections_openpackager_get_public+'\n'+\
            '4. private: '+sections_openpackager_get_private+'\n'+\
            '5. encryption: '+sections_openpackager_get_encryption+'\n'
        )

    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
print("-------------------------------")
print("Current Configuration Summary: ")
print("-------------------------------")
print("starting 'VirtualHuman' environment setup...")

## 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)

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()))

## 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
print('VIRTUALBODY: '+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

    """
    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 crafted adult filter
print('Adult Content Allowed?: '+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
print('Character: '+str(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)

## See the default Peer Age Status options and choises
print('Default Age: '+str(DEFAULT_AGE.get_status()))
print('Default Age Number: '+str(DEFAULT_AGE.get_number()))

## 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)

## Mod Shock Option Display
print('Mod shock: '+str(MODSHOCK.get()))

## Conclude output
print("-------------------------------")
print("Ending Virtual Human Setup.... ")
print("-------------------------------")